rx-player 4.0.0-dev.2023110700 → 4.0.0-dev.2023120600

package/dist/rx-player.js

@@ -11,88 +11,6 @@
 return /******/ (function() { // webpackBootstrap
 /******/ 	var __webpack_modules__ = ({
 
-/***/ 473:
-/***/ (function(module) {
-
-"use strict";
-
-
-var ensureCallable = function (fn) {
-	if (typeof fn !== 'function') throw new TypeError(fn + " is not a function");
-	return fn;
-};
-
-var byObserver = function (Observer) {
-	var node = document.createTextNode(''), queue, currentQueue, i = 0;
-	new Observer(function () {
-		var callback;
-		if (!queue) {
-			if (!currentQueue) return;
-			queue = currentQueue;
-		} else if (currentQueue) {
-			queue = currentQueue.concat(queue);
-		}
-		currentQueue = queue;
-		queue = null;
-		if (typeof currentQueue === 'function') {
-			callback = currentQueue;
-			currentQueue = null;
-			callback();
-			return;
-		}
-		node.data = (i = ++i % 2); // Invoke other batch, to handle leftover callbacks in case of crash
-		while (currentQueue) {
-			callback = currentQueue.shift();
-			if (!currentQueue.length) currentQueue = null;
-			callback();
-		}
-	}).observe(node, { characterData: true });
-	return function (fn) {
-		ensureCallable(fn);
-		if (queue) {
-			if (typeof queue === 'function') queue = [queue, fn];
-			else queue.push(fn);
-			return;
-		}
-		queue = fn;
-		node.data = (i = ++i % 2);
-	};
-};
-
-module.exports = (function () {
-	// Node.js
-	if ((typeof process === 'object') && process && (typeof process.nextTick === 'function')) {
-		return process.nextTick;
-	}
-
-	// queueMicrotask
-	if (typeof queueMicrotask === "function") {
-		return function (cb) { queueMicrotask(ensureCallable(cb)); };
-	}
-
-	// MutationObserver
-	if ((typeof document === 'object') && document) {
-		if (typeof MutationObserver === 'function') return byObserver(MutationObserver);
-		if (typeof WebKitMutationObserver === 'function') return byObserver(WebKitMutationObserver);
-	}
-
-	// W3C Draft
-	// http://dvcs.w3.org/hg/webperf/raw-file/tip/specs/setImmediate/Overview.html
-	if (typeof setImmediate === 'function') {
-		return function (cb) { setImmediate(ensureCallable(cb)); };
-	}
-
-	// Wide available standard
-	if ((typeof setTimeout === 'function') || (typeof setTimeout === 'object')) {
-		return function (cb) { setTimeout(ensureCallable(cb), 0); };
-	}
-
-	return null;
-}());
-
-
-/***/ }),
-
 /***/ 61:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
@@ -617,6 +535,11 @@ var DEFAULT_CONFIG = {
    * @type {Number}
    */
   DEFAULT_REQUEST_TIMEOUT: 30 * 1000,
+  /**
+   * Default connection time after which a request will timeout, in ms.
+   * @type {Number}
+   */
+  DEFAULT_CONNECTION_TIMEOUT: 15 * 1000,
   /**
    * Can be either:
    *   - "native": Subtitles are all displayed in a <track> element
@@ -5206,6 +5129,12 @@ function checkReloadOptions(options) {
   if (typeof ((_c = options === null || options === void 0 ? void 0 : options.reloadAt) === null || _c === void 0 ? void 0 : _c.relative) !== "number" && ((_d = options === null || options === void 0 ? void 0 : options.reloadAt) === null || _d === void 0 ? void 0 : _d.relative) !== undefined) {
     throw new Error("API: reload - Invalid 'reloadAt.relative' option format.");
   }
+  if (!Array.isArray(options === null || options === void 0 ? void 0 : options.keySystems) && (options === null || options === void 0 ? void 0 : options.keySystems) !== undefined) {
+    throw new Error("API: reload - Invalid 'keySystems' option format.");
+  }
+  if ((options === null || options === void 0 ? void 0 : options.autoPlay) !== undefined && typeof options.autoPlay !== "boolean") {
+    throw new Error("API: reload - Invalid 'autoPlay' option format.");
+  }
 }
 /**
  * Parse options given to loadVideo and set default options as found
@@ -5291,8 +5220,7 @@ function parseLoadVideoOptions(options) {
     src_log.warn("API: You have set a textTrackElement without being in " + "an \"html\" textTrackMode. It will be ignored.");
   }
   if (!is_null_or_undefined_isNullOrUndefined(options.startAt)) {
-    // TODO Better way to express that in TypeScript?
-    if (options.startAt.wallClockTime instanceof Date) {
+    if ("wallClockTime" in options.startAt && options.startAt.wallClockTime instanceof Date) {
       var wallClockTime = options.startAt.wallClockTime.getTime() / 1000;
       startAt = object_assign({}, options.startAt, {
         wallClockTime: wallClockTime
@@ -7375,7 +7303,7 @@ var Player = /*#__PURE__*/function (_EventEmitter) {
     // Workaround to support Firefox autoplay on FF 42.
     // See: https://bugzilla.mozilla.org/show_bug.cgi?id=1194624
     videoElement.preload = "auto";
-    _this.version = /* PLAYER_VERSION */"4.0.0-dev.2023110700";
+    _this.version = /* PLAYER_VERSION */"4.0.0-dev.2023120600";
     _this.log = src_log;
     _this.state = "STOPPED";
     _this.videoElement = videoElement;
@@ -7474,7 +7402,7 @@ var Player = /*#__PURE__*/function (_EventEmitter) {
    * @param {Object} reloadOpts
    */;
   _proto.reload = function reload(reloadOpts) {
-    var _a, _b;
+    var _a, _b, _c;
     var _this$_priv_reloading = this._priv_reloadingMetadata,
       options = _this$_priv_reloading.options,
       manifest = _this$_priv_reloading.manifest,
@@ -7508,6 +7436,12 @@ var Player = /*#__PURE__*/function (_EventEmitter) {
     } else if (reloadInPause !== undefined) {
       autoPlay = !reloadInPause;
     }
+    var keySystems;
+    if ((reloadOpts === null || reloadOpts === void 0 ? void 0 : reloadOpts.keySystems) !== undefined) {
+      keySystems = reloadOpts.keySystems;
+    } else if (((_c = this._priv_reloadingMetadata.options) === null || _c === void 0 ? void 0 : _c.keySystems) !== undefined) {
+      keySystems = this._priv_reloadingMetadata.options.keySystems;
+    }
     var newOptions = Object.assign(Object.assign({}, options), {
       initialManifest: manifest
     });
@@ -7517,6 +7451,9 @@ var Player = /*#__PURE__*/function (_EventEmitter) {
     if (autoPlay !== undefined) {
       newOptions.autoPlay = autoPlay;
     }
+    if (keySystems !== undefined) {
+      newOptions.keySystems = keySystems;
+    }
     this._priv_initializeContentPlayback(newOptions);
   };
   _proto.createDebugElement = function createDebugElement(element) {
@@ -7537,7 +7474,7 @@ var Player = /*#__PURE__*/function (_EventEmitter) {
    */;
   _proto._priv_initializeContentPlayback = function _priv_initializeContentPlayback(options) {
     var _this2 = this;
-    var _a, _b, _c, _d;
+    var _a, _b, _c, _d, _e, _f;
     var autoPlay = options.autoPlay,
       defaultAudioTrackSwitchingMode = options.defaultAudioTrackSwitchingMode,
       enableFastSwitching = options.enableFastSwitching,
@@ -7595,6 +7532,7 @@ var Player = /*#__PURE__*/function (_EventEmitter) {
         lowLatencyMode: lowLatencyMode,
         maxRetry: (_a = requestConfig.manifest) === null || _a === void 0 ? void 0 : _a.maxRetry,
         requestTimeout: (_b = requestConfig.manifest) === null || _b === void 0 ? void 0 : _b.timeout,
+        connectionTimeout: (_c = requestConfig.manifest) === null || _c === void 0 ? void 0 : _c.connectionTimeout,
         minimumManifestUpdateInterval: minimumManifestUpdateInterval,
         initialManifest: initialManifest
       };
@@ -7646,8 +7584,9 @@ var Player = /*#__PURE__*/function (_EventEmitter) {
       }, this._priv_bufferOptions);
       var segmentRequestOptions = {
         lowLatencyMode: lowLatencyMode,
-        maxRetry: (_c = requestConfig.segment) === null || _c === void 0 ? void 0 : _c.maxRetry,
-        requestTimeout: (_d = requestConfig.segment) === null || _d === void 0 ? void 0 : _d.timeout
+        maxRetry: (_d = requestConfig.segment) === null || _d === void 0 ? void 0 : _d.maxRetry,
+        requestTimeout: (_e = requestConfig.segment) === null || _e === void 0 ? void 0 : _e.timeout,
+        connectionTimeout: (_f = requestConfig.segment) === null || _f === void 0 ? void 0 : _f.connectionTimeout
       };
       initializer = new src_features.mediaSourceInit({
         adaptiveOptions: adaptiveOptions,
@@ -8874,16 +8813,39 @@ var Player = /*#__PURE__*/function (_EventEmitter) {
     return null;
   }
   /**
-   * Get maximum seek-able position.
+   * Returns the current position for live contents.
+   *
+   * Returns `null` if no content is loaded or if the current loaded content is
+   * not considered as a live content.
+   * Returns `undefined` if that live position is currently unknown.
    * @returns {number}
    */;
-  _proto.getMaximumPosition = function getMaximumPosition() {
+  _proto.getLivePosition = function getLivePosition() {
     if (this._priv_contentInfos === null) {
       return null;
     }
     var _this$_priv_contentIn17 = this._priv_contentInfos,
       isDirectFile = _this$_priv_contentIn17.isDirectFile,
       manifest = _this$_priv_contentIn17.manifest;
+    if (isDirectFile) {
+      return undefined;
+    }
+    if ((manifest === null || manifest === void 0 ? void 0 : manifest.isLive) !== true) {
+      return null;
+    }
+    return manifest.getLivePosition();
+  }
+  /**
+   * Get maximum seek-able position.
+   * @returns {number}
+   */;
+  _proto.getMaximumPosition = function getMaximumPosition() {
+    if (this._priv_contentInfos === null) {
+      return null;
+    }
+    var _this$_priv_contentIn18 = this._priv_contentInfos,
+      isDirectFile = _this$_priv_contentIn18.isDirectFile,
+      manifest = _this$_priv_contentIn18.manifest;
     if (isDirectFile) {
       if (this.videoElement === null) {
         throw new Error("Disposed player");
@@ -8917,7 +8879,11 @@ var Player = /*#__PURE__*/function (_EventEmitter) {
       return null;
     }
     var segmentBufferStatus = this._priv_contentInfos.segmentBuffersStore.getStatus(bufferType);
-    return segmentBufferStatus.type === "initialized" ? segmentBufferStatus.value.getInventory() : null;
+    if (segmentBufferStatus.type === "initialized") {
+      segmentBufferStatus.value.synchronizeInventory();
+      return segmentBufferStatus.value.getInventory();
+    }
+    return null;
   }
   /**
    * /!\ For tools use only! Do not touch!
@@ -8940,9 +8906,9 @@ var Player = /*#__PURE__*/function (_EventEmitter) {
     if (this._priv_contentInfos === null) {
       return null;
     }
-    var _this$_priv_contentIn18 = this._priv_contentInfos,
-      currentPeriod = _this$_priv_contentIn18.currentPeriod,
-      activeAdaptations = _this$_priv_contentIn18.activeAdaptations;
+    var _this$_priv_contentIn19 = this._priv_contentInfos,
+      currentPeriod = _this$_priv_contentIn19.currentPeriod,
+      activeAdaptations = _this$_priv_contentIn19.activeAdaptations;
     if (currentPeriod === null || activeAdaptations === null || is_null_or_undefined_isNullOrUndefined(activeAdaptations[currentPeriod.id])) {
       return null;
     }
@@ -8954,9 +8920,9 @@ var Player = /*#__PURE__*/function (_EventEmitter) {
     if (this._priv_contentInfos === null) {
       return null;
     }
-    var _this$_priv_contentIn19 = this._priv_contentInfos,
-      currentPeriod = _this$_priv_contentIn19.currentPeriod,
-      activeRepresentations = _this$_priv_contentIn19.activeRepresentations;
+    var _this$_priv_contentIn20 = this._priv_contentInfos,
+      currentPeriod = _this$_priv_contentIn20.currentPeriod,
+      activeRepresentations = _this$_priv_contentIn20.activeRepresentations;
     if (currentPeriod === null || activeRepresentations === null || is_null_or_undefined_isNullOrUndefined(activeRepresentations[currentPeriod.id])) {
       return null;
     }
@@ -9573,7 +9539,7 @@ var Player = /*#__PURE__*/function (_EventEmitter) {
   }]);
   return Player;
 }(EventEmitter);
-Player.version = /* PLAYER_VERSION */"4.0.0-dev.2023110700";
+Player.version = /* PLAYER_VERSION */"4.0.0-dev.2023120600";
 /* harmony default export */ var public_api = (Player);
 ;// CONCATENATED MODULE: ./src/core/api/index.ts
 /**
@@ -11935,6 +11901,16 @@ var READY_STATES = {
  * limitations under the License.
  */
 
+/**
+ * Setting this value limit the number of entries in the support map
+ * preventing important memory usage, value is arbitrary
+ */
+var MAX_SUPPORT_MAP_ENTRIES = 200;
+/**
+ * caching the codec support reduce the amount of call to `isTypeSupported`
+ * and help for performance especially on low-end devices.
+ */
+var supportMap = new Map();
 /**
  * Returns true if the given codec is supported by the browser's MediaSource
  * implementation.
@@ -11951,7 +11927,17 @@ function isCodecSupported(mimeType) {
   /* eslint-disable @typescript-eslint/unbound-method */
   if (typeof MediaSource_.isTypeSupported === "function") {
     /* eslint-enable @typescript-eslint/unbound-method */
-    return MediaSource_.isTypeSupported(mimeType);
+    var cachedSupport = supportMap.get(mimeType);
+    if (cachedSupport !== undefined) {
+      return cachedSupport;
+    } else {
+      var isSupported = MediaSource_.isTypeSupported(mimeType);
+      if (supportMap.size >= MAX_SUPPORT_MAP_ENTRIES) {
+        supportMap.clear();
+      }
+      supportMap.set(mimeType, isSupported);
+      return isSupported;
+    }
   }
   return true;
 }
@@ -12024,6 +12010,7 @@ var Representation = /*#__PURE__*/function () {
    * @param {Object} args
    */
   function Representation(args, opts) {
+    var _a;
     this.id = args.id;
     this.uniqueId = generateRepresentationUniqueId();
     this.bitrate = args.bitrate;
@@ -12052,12 +12039,24 @@ var Representation = /*#__PURE__*/function () {
     this.cdnMetadata = args.cdnMetadata;
     this.index = args.index;
     if (opts.type === "audio" || opts.type === "video") {
-      var mimeTypeStr = this.getMimeTypeString();
-      var isSupported = isCodecSupported(mimeTypeStr);
-      if (!isSupported) {
-        src_log.info("Unsupported Representation", mimeTypeStr, this.id, this.bitrate);
+      this.isSupported = false;
+      // Supplemental codecs are defined as backwards-compatible codecs enhancing
+      // the experience of a base layer codec
+      if (args.supplementalCodecs !== undefined) {
+        var supplementalCodecMimeTypeStr = ((_a = this.mimeType) !== null && _a !== void 0 ? _a : "") + ";codecs=\"" + args.supplementalCodecs + "\"";
+        if (isCodecSupported(supplementalCodecMimeTypeStr)) {
+          this.codec = args.supplementalCodecs;
+          this.isSupported = true;
+        }
+      }
+      if (!this.isSupported) {
+        var mimeTypeStr = this.getMimeTypeString();
+        var isSupported = isCodecSupported(mimeTypeStr);
+        if (!isSupported) {
+          src_log.info("Unsupported Representation", mimeTypeStr, this.id, this.bitrate);
+        }
+        this.isSupported = isSupported;
       }
-      this.isSupported = isSupported;
     } else {
       this.isSupported = true; // TODO for other types
     }
@@ -13992,7 +13991,6 @@ function manifest_fetcher_arrayLikeToArray(arr, len) { if (len == null || len >
 
 
 
-
 /**
  * Class allowing to facilitate the task of loading and parsing a Manifest, as
  * well as automatically refreshing it.
@@ -14117,13 +14115,18 @@ var ManifestFetcher = /*#__PURE__*/function (_EventEmitter) {
           case 0:
             callLoaderWithRetries = function _callLoaderWithRetrie(manifestUrl) {
               var loadManifest = pipelines.loadManifest;
-              var requestTimeout = is_null_or_undefined_isNullOrUndefined(settings.requestTimeout) ? config.getCurrent().DEFAULT_REQUEST_TIMEOUT : settings.requestTimeout;
+              var requestTimeout = settings.requestTimeout === undefined ? config.getCurrent().DEFAULT_REQUEST_TIMEOUT : settings.requestTimeout;
+              var connectionTimeout = settings.connectionTimeout === undefined ? config.getCurrent().DEFAULT_CONNECTION_TIMEOUT : settings.connectionTimeout;
               if (requestTimeout < 0) {
                 requestTimeout = undefined;
               }
+              if (connectionTimeout < 0) {
+                connectionTimeout = undefined;
+              }
               var callLoader = function callLoader() {
                 return loadManifest(manifestUrl, {
-                  timeout: requestTimeout
+                  timeout: requestTimeout,
+                  connectionTimeout: connectionTimeout
                 }, cancelSignal);
               };
               return scheduleRequestPromise(callLoader, backoffSettings, cancelSignal);
@@ -14979,7 +14982,8 @@ var generateRequestID = idGenerator();
  */
 function segment_fetcher_createSegmentFetcher(bufferType, pipeline, cdnPrioritizer, lifecycleCallbacks, options) {
   var requestOptions = {
-    timeout: options.requestTimeout < 0 ? undefined : options.requestTimeout
+    timeout: options.requestTimeout < 0 ? undefined : options.requestTimeout,
+    connectionTimeout: options.connectionTimeout === undefined ? undefined : options.connectionTimeout < 0 ? undefined : options.connectionTimeout
   };
   /**
    * Cache audio and video initialization segments.
@@ -15222,17 +15226,20 @@ function segment_fetcher_createSegmentFetcher(bufferType, pipeline, cdnPrioritiz
 function getSegmentFetcherOptions(_ref) {
   var maxRetry = _ref.maxRetry,
     lowLatencyMode = _ref.lowLatencyMode,
-    requestTimeout = _ref.requestTimeout;
+    requestTimeout = _ref.requestTimeout,
+    connectionTimeout = _ref.connectionTimeout;
   var _config$getCurrent = config.getCurrent(),
     DEFAULT_MAX_REQUESTS_RETRY_ON_ERROR = _config$getCurrent.DEFAULT_MAX_REQUESTS_RETRY_ON_ERROR,
     DEFAULT_REQUEST_TIMEOUT = _config$getCurrent.DEFAULT_REQUEST_TIMEOUT,
+    DEFAULT_CONNECTION_TIMEOUT = _config$getCurrent.DEFAULT_CONNECTION_TIMEOUT,
     INITIAL_BACKOFF_DELAY_BASE = _config$getCurrent.INITIAL_BACKOFF_DELAY_BASE,
     MAX_BACKOFF_DELAY_BASE = _config$getCurrent.MAX_BACKOFF_DELAY_BASE;
   return {
     maxRetry: maxRetry !== null && maxRetry !== void 0 ? maxRetry : DEFAULT_MAX_REQUESTS_RETRY_ON_ERROR,
     baseDelay: lowLatencyMode ? INITIAL_BACKOFF_DELAY_BASE.LOW_LATENCY : INITIAL_BACKOFF_DELAY_BASE.REGULAR,
     maxDelay: lowLatencyMode ? MAX_BACKOFF_DELAY_BASE.LOW_LATENCY : MAX_BACKOFF_DELAY_BASE.REGULAR,
-    requestTimeout: is_null_or_undefined_isNullOrUndefined(requestTimeout) ? DEFAULT_REQUEST_TIMEOUT : requestTimeout
+    requestTimeout: requestTimeout === undefined ? DEFAULT_REQUEST_TIMEOUT : requestTimeout,
+    connectionTimeout: connectionTimeout === undefined ? DEFAULT_CONNECTION_TIMEOUT : connectionTimeout
   };
 }
 ;// CONCATENATED MODULE: ./src/core/fetchers/segment/task_prioritizer.ts
@@ -17514,9 +17521,12 @@ function shouldHaveNativeBuffer(bufferType) {
 
 /* harmony default export */ var segment_buffers = (SegmentBuffersStore);
 
-// EXTERNAL MODULE: ./node_modules/next-tick/index.js
-var next_tick = __webpack_require__(473);
-var next_tick_default = /*#__PURE__*/__webpack_require__.n(next_tick);
+;// CONCATENATED MODULE: ./src/utils/queue_microtask.ts
+/* harmony default export */ var queue_microtask = (typeof queueMicrotask === "function" ? queueMicrotask : function queueMicrotaskPonyfill(cb) {
+  Promise.resolve().then(cb, function () {
+    return cb();
+  });
+});
 ;// CONCATENATED MODULE: ./src/utils/sorted_list.ts
 /**
  * Copyright 2015 CANAL+ Group
@@ -18934,7 +18944,7 @@ function doesEndSeemGarbageCollected(currentSeg, nextSeg, minimumEndTime) {
     return false;
   }
   if (minimumEndTime > currentSeg.bufferedEnd && currentSeg.end - currentSeg.bufferedEnd > MAX_TIME_MISSING_FROM_COMPLETE_SEGMENT) {
-    src_log.info("Stream: The end of the wanted segment has been garbage collected", currentSeg.start, currentSeg.bufferedStart);
+    src_log.info("Stream: The end of the wanted segment has been garbage collected", currentSeg.end, currentSeg.bufferedEnd);
     return true;
   }
   return false;
@@ -19158,7 +19168,7 @@ function getBufferStatus(content, initialWantedTime, playbackObserver, fastSwitc
    * `true` if the current `RepresentationStream` has loaded all the
    * needed segments for this Representation until the end of the Period.
    */
-  var hasFinishedLoading = representation.index.isInitialized() && representation.index.isFinished() && neededRange.hasReachedPeriodEnd && prioritizedNeededSegments.length === 0 && segmentsOnHold.length === 0;
+  var hasFinishedLoading = representation.index.isInitialized() && !representation.index.isStillAwaitingFutureSegments() && neededRange.hasReachedPeriodEnd && prioritizedNeededSegments.length === 0 && segmentsOnHold.length === 0;
   /**
    * Start time in seconds of the next available not-yet pushed segment.
    * `null` if no segment is wanted for the current wanted range.
@@ -19207,14 +19217,14 @@ function getRangeOfNeededSegments(content, initialWantedTime, bufferGoal) {
   // In that case, we want to actually request at least the last segment to
   // avoid ending the last Period - and by extension the content - with a
   // segment which isn't the last one.
-  if (!is_null_or_undefined_isNullOrUndefined(lastIndexPosition) && segment_buffers.isNative(content.adaptation.type) && initialWantedTime >= lastIndexPosition && representationIndex.isInitialized() && representationIndex.isFinished() && isPeriodTheCurrentAndLastOne(manifest, period, initialWantedTime)) {
+  if (!is_null_or_undefined_isNullOrUndefined(lastIndexPosition) && segment_buffers.isNative(content.adaptation.type) && initialWantedTime >= lastIndexPosition && representationIndex.isInitialized() && !representationIndex.isStillAwaitingFutureSegments() && isPeriodTheCurrentAndLastOne(manifest, period, initialWantedTime)) {
     wantedStartPosition = lastIndexPosition - 1;
   } else {
     wantedStartPosition = initialWantedTime - 0.1;
   }
   var wantedEndPosition = wantedStartPosition + bufferGoal;
   var hasReachedPeriodEnd;
-  if (!representation.index.isInitialized() || !representation.index.isFinished() || period.end === undefined) {
+  if (!representation.index.isInitialized() || representation.index.isStillAwaitingFutureSegments() || period.end === undefined) {
     hasReachedPeriodEnd = false;
   } else if (lastIndexPosition === undefined) {
     // We do not know the end of this index.
@@ -20514,7 +20524,7 @@ function AdaptationStream(_ref, callbacks, parentCancelSignal) {
           case 4:
             return _context.abrupt("break", 21);
           case 5:
-            return _context.abrupt("return", next_tick_default()(function () {
+            return _context.abrupt("return", queue_microtask(function () {
               playbackObserver.listen(function () {
                 if (fnCancelSignal.isCancelled()) {
                   return;
@@ -21447,7 +21457,7 @@ function PeriodStream(_ref, callbacks, parentCancelSignal) {
     // is actually received.
     // It can happen when `askForMediaSourceReload` is called as a side-effect of
     // the same event that triggers the playback observation to be emitted.
-    next_tick_default()(function () {
+    queue_microtask(function () {
       playbackObserver.listen(function () {
         if (cancelSignal.isCancelled()) {
           return;
@@ -21979,7 +21989,7 @@ function StreamOrchestrator(content, playbackObserver, representationEstimator,
               // Schedule micro task before checking the last playback observation
               // to reduce the risk of race conditions where the next observation
               // was going to be emitted synchronously.
-              next_tick_default()(function () {
+              queue_microtask(function () {
                 var _a;
                 if (orchestratorCancelSignal.isCancelled()) {
                   return;
@@ -22166,7 +22176,7 @@ function StreamOrchestrator(content, playbackObserver, representationEstimator,
               // conditions where the inner logic would be called synchronously before
               // the next observation (which may reflect very different playback
               // conditions) is actually received.
-              return next_tick_default()(function () {
+              return queue_microtask(function () {
                 if (innerCancelSignal.isCancelled()) {
                   return;
                 }
@@ -22321,8 +22331,8 @@ function content_time_boundaries_observer_arrayLikeToArray(arr, len) { if (len =
 /**
  * Observes what's being played and take care of media events relating to time
  * boundaries:
- *   - Emits a `durationUpdate` when the duration of the current content is
- *     known and every time it changes.
+ *   - Emits a `endingPositionChange` when the known maximum playable position
+ *     of the current content is known and every time it changes.
  *   - Emits `endOfStream` API once segments have been pushed until the end and
  *     `resumeStream` if downloads starts back.
  *   - Emits a `periodChange` event when the currently-playing Period seemed to
@@ -22368,7 +22378,7 @@ var ContentTimeBoundariesObserver = /*#__PURE__*/function (_EventEmitter) {
       clearSignal: cancelSignal
     });
     manifest.addEventListener("manifestUpdate", function () {
-      _this.trigger("durationUpdate", _this._getManifestDuration());
+      _this.trigger("endingPositionChange", _this._getManifestEndTime());
       if (cancelSignal.isCancelled()) {
         return;
       }
@@ -22377,12 +22387,13 @@ var ContentTimeBoundariesObserver = /*#__PURE__*/function (_EventEmitter) {
     return _this;
   }
   /**
-   * Returns an estimate of the current duration of the content.
+   * Returns an estimate of the current last position which may be played in
+   * the content at the moment.
    * @returns {Object}
    */
   var _proto = ContentTimeBoundariesObserver.prototype;
-  _proto.getCurrentDuration = function getCurrentDuration() {
-    return this._getManifestDuration();
+  _proto.getCurrentEndingTime = function getCurrentEndingTime() {
+    return this._getManifestEndTime();
   }
   /**
    * Method to call any time an Adaptation has been selected.
@@ -22408,14 +22419,14 @@ var ContentTimeBoundariesObserver = /*#__PURE__*/function (_EventEmitter) {
             this._maximumPositionCalculator.updateLastVideoAdaptation(adaptation);
           }
           var endingPosition = this._maximumPositionCalculator.getEndingPosition();
-          var newDuration = endingPosition !== undefined ? {
+          var newEndingPosition = endingPosition !== undefined ? {
             isEnd: true,
-            duration: endingPosition
+            endingPosition: endingPosition
           } : {
             isEnd: false,
-            duration: this._maximumPositionCalculator.getMaximumAvailablePosition()
+            endingPosition: this._maximumPositionCalculator.getMaximumAvailablePosition()
           };
-          this.trigger("durationUpdate", newDuration);
+          this.trigger("endingPositionChange", newEndingPosition);
         }
       }
     }
@@ -22555,14 +22566,14 @@ var ContentTimeBoundariesObserver = /*#__PURE__*/function (_EventEmitter) {
       if (_ret) return _ret.v;
     }
   };
-  _proto._getManifestDuration = function _getManifestDuration() {
+  _proto._getManifestEndTime = function _getManifestEndTime() {
     var endingPosition = this._maximumPositionCalculator.getEndingPosition();
     return endingPosition !== undefined ? {
       isEnd: true,
-      duration: endingPosition
+      endingPosition: endingPosition
     } : {
       isEnd: false,
-      duration: this._maximumPositionCalculator.getMaximumAvailablePosition()
+      endingPosition: this._maximumPositionCalculator.getMaximumAvailablePosition()
     };
   };
   _proto._lazilyCreateActiveStreamInfo = function _lazilyCreateActiveStreamInfo(bufferType) {
@@ -22639,9 +22650,8 @@ var MaximumPositionCalculator = /*#__PURE__*/function () {
    * @returns {number}
    */;
   _proto2.getMaximumAvailablePosition = function getMaximumAvailablePosition() {
-    var _a;
     if (this._manifest.isDynamic) {
-      return (_a = this._manifest.getLivePosition()) !== null && _a !== void 0 ? _a : this._manifest.getMaximumSafePosition();
+      return this._manifest.getMaximumSafePosition();
     }
     if (this._lastVideoAdaptation === undefined || this._lastAudioAdaptation === undefined) {
       return this._manifest.getMaximumSafePosition();
@@ -23157,15 +23167,10 @@ function maintainEndOfStream(mediaSource, cancelSignal) {
  * @returns {Number}
  */
 function getInitialTime(manifest, lowLatencyMode, startAt) {
+  var _a;
   if (!is_null_or_undefined_isNullOrUndefined(startAt)) {
     var min = manifest.getMinimumSafePosition();
-    var max;
-    if (manifest.isLive) {
-      max = manifest.getLivePosition();
-    }
-    if (max === undefined) {
-      max = manifest.getMaximumSafePosition();
-    }
+    var max = manifest.getMaximumSafePosition();
     if (!is_null_or_undefined_isNullOrUndefined(startAt.position)) {
       src_log.debug("Init: using startAt.minimumPosition");
       return Math.max(Math.min(startAt.position, max), min);
@@ -23182,6 +23187,11 @@ function getInitialTime(manifest, lowLatencyMode, startAt) {
       src_log.debug("Init: using startAt.fromLastPosition");
       var fromLastPosition = startAt.fromLastPosition;
       return fromLastPosition >= 0 ? max : Math.max(min, max + fromLastPosition);
+    } else if (!is_null_or_undefined_isNullOrUndefined(startAt.fromLivePosition)) {
+      src_log.debug("Init: using startAt.fromLivePosition");
+      var livePosition = (_a = manifest.getLivePosition()) !== null && _a !== void 0 ? _a : max;
+      var fromLivePosition = startAt.fromLivePosition;
+      return fromLivePosition >= 0 ? livePosition : Math.max(min, livePosition + fromLivePosition);
     } else if (!is_null_or_undefined_isNullOrUndefined(startAt.percentage)) {
       src_log.debug("Init: using startAt.percentage");
       var percentage = startAt.percentage;
@@ -25359,7 +25369,7 @@ var MediaSourceContentInitializer = /*#__PURE__*/function (_ContentInitializer)
             if (
             // Data is buffered around the current position
             obs.currentRange !== null ||
-            // Or, for whatever reason, playback is already advancing
+            // Or, for whatever reason, we have no buffer but we're already advancing
             obs.position > seekedTime + 0.1) {
               stopListening();
               playbackObserver.setCurrentTime(obs.position + 0.001);
@@ -25542,8 +25552,8 @@ var MediaSourceContentInitializer = /*#__PURE__*/function (_ContentInitializer)
         period: period
       });
     });
-    contentTimeBoundariesObserver.addEventListener("durationUpdate", function (newDuration) {
-      mediaSourceDurationUpdater.updateDuration(newDuration.duration, newDuration.isEnd);
+    contentTimeBoundariesObserver.addEventListener("endingPositionChange", function (x) {
+      return mediaSourceDurationUpdater.updateDuration(x.endingPosition, x.isEnd);
     });
     contentTimeBoundariesObserver.addEventListener("endOfStream", function () {
       if (endOfStreamCanceller === null) {
@@ -25560,8 +25570,8 @@ var MediaSourceContentInitializer = /*#__PURE__*/function (_ContentInitializer)
         endOfStreamCanceller = null;
       }
     });
-    var currentDuration = contentTimeBoundariesObserver.getCurrentDuration();
-    mediaSourceDurationUpdater.updateDuration(currentDuration.duration, currentDuration.isEnd);
+    var endInfo = contentTimeBoundariesObserver.getCurrentEndingTime();
+    mediaSourceDurationUpdater.updateDuration(endInfo.endingPosition, endInfo.isEnd);
     return contentTimeBoundariesObserver;
   }
   /**
@@ -27168,7 +27178,7 @@ function getTimescaledRange(start, duration, timescale) {
  * timescaled time.
  * Returns -1 if the given time is lower than the start of the first available
  * segment.
- * @param {Object} index
+ * @param {Object} timeline
  * @param {Number} timeTScaled
  * @returns {Number}
  */
@@ -27213,55 +27223,6 @@ function index_helpers_checkDiscontinuity(index, timeSec, maxPosition) {
   var segmentEnd = getIndexSegmentEnd(timelineItem, nextTimelineItem, maxPosition);
   return scaledTime >= segmentEnd && scaledTime < nextStart ? fromIndexTime(nextStart, index) : null;
 }
-;// CONCATENATED MODULE: ./src/parsers/manifest/utils/is_segment_still_available.ts
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-/**
- * Returns true if a Segment returned by the corresponding index is still
- * considered available.
- * Returns false if it is not available anymore.
- * Returns undefined if we cannot know whether it is still available or not.
- * /!\ We do not check the mediaURLs of the segment.
- * @param {Object} segment
- * @param {Array.<Object>} timescale
- * @param {number} timeline
- * @returns {Boolean|undefined}
- */
-function is_segment_still_available_isSegmentStillAvailable(segment, timeline, timescale, indexTimeOffset) {
-  for (var i = 0; i < timeline.length; i++) {
-    var tSegment = timeline[i];
-    var tSegmentTime = (tSegment.start - indexTimeOffset) / timescale;
-    if (tSegmentTime > segment.time) {
-      return false;
-    } else if (tSegmentTime === segment.time) {
-      if (tSegment.range === undefined) {
-        return segment.range === undefined;
-      }
-      return segment.range != null && tSegment.range[0] === segment.range[0] && tSegment.range[1] === segment.range[1];
-    } else {
-      // tSegment.start < segment.time
-      if (tSegment.repeatCount >= 0 && tSegment.duration !== undefined) {
-        var timeDiff = tSegmentTime - tSegment.start;
-        var repeat = timeDiff / tSegment.duration - 1;
-        return repeat % 1 === 0 && repeat <= tSegment.repeatCount;
-      }
-    }
-  }
-  return false;
-}
 ;// CONCATENATED MODULE: ./src/parsers/manifest/smooth/utils/tokens.ts
 /**
  * Copyright 2015 CANAL+ Group
@@ -27317,7 +27278,6 @@ function replaceSegmentSmoothTokens(url, time) {
 
 
 
-
 /**
  * @param {Number} start
  * @param {Number} up
@@ -27587,7 +27547,7 @@ var SmoothRepresentationIndex = /*#__PURE__*/function () {
   _proto.awaitSegmentBetween = function awaitSegmentBetween(start, end) {
     var _a;
     assert_assert(start <= end);
-    if (this.isFinished()) {
+    if (this.isStillAwaitingFutureSegments()) {
       return false;
     }
     var lastAvailablePosition = this.getLastAvailablePosition();
@@ -27625,7 +27585,23 @@ var SmoothRepresentationIndex = /*#__PURE__*/function () {
     var _this$_sharedSmoothTi5 = this._sharedSmoothTimeline,
       timeline = _this$_sharedSmoothTi5.timeline,
       timescale = _this$_sharedSmoothTi5.timescale;
-    return is_segment_still_available_isSegmentStillAvailable(segment, timeline, timescale, 0);
+    for (var i = 0; i < timeline.length; i++) {
+      var tSegment = timeline[i];
+      var tSegmentTime = tSegment.start / timescale;
+      if (tSegmentTime > segment.time) {
+        return false; // We went over it without finding it
+      } else if (tSegmentTime === segment.time) {
+        return true;
+      } else {
+        // tSegment.start < segment.time
+        if (tSegment.repeatCount >= 0 && tSegment.duration !== undefined) {
+          var timeDiff = tSegmentTime - tSegment.start;
+          var repeat = timeDiff / tSegment.duration - 1;
+          return repeat % 1 === 0 && repeat <= tSegment.repeatCount;
+        }
+      }
+    }
+    return false;
   }
   /**
    * @param {Error} error
@@ -27658,9 +27634,9 @@ var SmoothRepresentationIndex = /*#__PURE__*/function () {
     this._sharedSmoothTimeline.update(newIndex._sharedSmoothTimeline);
   }
   /**
-   * Returns `true` if the last segments in this index have already been
+   * Returns `false` if the last segments in this index have already been
    * generated.
-   * Returns `false` if the index is still waiting on future segments to be
+   * Returns `true` if the index is still waiting on future segments to be
    * generated.
    *
    * For Smooth, it should only depend on whether the content is a live content
@@ -27668,8 +27644,8 @@ var SmoothRepresentationIndex = /*#__PURE__*/function () {
    * TODO What about Smooth live content that finishes at some point?
    * @returns {boolean}
    */;
-  _proto.isFinished = function isFinished() {
-    return !this._isLive;
+  _proto.isStillAwaitingFutureSegments = function isStillAwaitingFutureSegments() {
+    return this._isLive;
   }
   /**
    * @returns {Boolean}
@@ -27684,8 +27660,8 @@ var SmoothRepresentationIndex = /*#__PURE__*/function () {
    * Add segments to a `SharedSmoothSegmentTimeline` that were predicted to come
    * after `currentSegment`.
    * @param {Array.<Object>} nextSegments - The segment information parsed.
-   * @param {Object} segment - Information on the segment which contained that
-   * new segment information.
+   * @param {Object} currentSegment - Information on the segment which contained
+   * that new segment information.
    */;
   _proto.addPredictedSegments = function addPredictedSegments(nextSegments, currentSegment) {
     this._sharedSmoothTimeline.addPredictedSegments(nextSegments, currentSegment);
@@ -28735,7 +28711,8 @@ function request(options) {
     url: options.url,
     headers: options.headers,
     responseType: is_null_or_undefined_isNullOrUndefined(options.responseType) ? DEFAULT_RESPONSE_TYPE : options.responseType,
-    timeout: options.timeout
+    timeout: options.timeout,
+    connectionTimeout: options.connectionTimeout
   };
   return new Promise(function (resolve, reject) {
     var onProgress = options.onProgress,
@@ -28743,7 +28720,8 @@ function request(options) {
     var url = requestOptions.url,
       headers = requestOptions.headers,
       responseType = requestOptions.responseType,
-      timeout = requestOptions.timeout;
+      timeout = requestOptions.timeout,
+      connectionTimeout = requestOptions.connectionTimeout;
     var xhr = new XMLHttpRequest();
     xhr.open("GET", url, true);
     var timeoutId;
@@ -28757,9 +28735,19 @@ function request(options) {
       // is more precise, it might also be more efficient.
       timeoutId = setTimeout(function () {
         clearCancellingProcess();
-        reject(new RequestError(url, xhr.status, "TIMEOUT"));
+        reject(new RequestError(url, xhr.status, NetworkErrorTypes.TIMEOUT));
       }, timeout + 3000);
     }
+    var connectionTimeoutId;
+    if (connectionTimeout !== undefined) {
+      connectionTimeoutId = setTimeout(function () {
+        clearCancellingProcess();
+        if (xhr.readyState !== XMLHttpRequest.DONE) {
+          xhr.abort();
+        }
+        reject(new RequestError(url, xhr.status, NetworkErrorTypes.TIMEOUT));
+      }, connectionTimeout);
+    }
     xhr.responseType = responseType;
     if (xhr.responseType === "document") {
       xhr.overrideMimeType("text/xml");
@@ -28778,7 +28766,7 @@ function request(options) {
     if (cancelSignal !== undefined) {
       deregisterCancellationListener = cancelSignal.register(function abortRequest(err) {
         clearCancellingProcess();
-        if (!is_null_or_undefined_isNullOrUndefined(xhr) && xhr.readyState !== 4) {
+        if (xhr.readyState !== XMLHttpRequest.DONE) {
           xhr.abort();
         }
         reject(err);
@@ -28789,12 +28777,19 @@ function request(options) {
     }
     xhr.onerror = function onXHRError() {
       clearCancellingProcess();
-      reject(new RequestError(url, xhr.status, "ERROR_EVENT"));
+      reject(new RequestError(url, xhr.status, NetworkErrorTypes.ERROR_EVENT));
     };
     xhr.ontimeout = function onXHRTimeout() {
       clearCancellingProcess();
-      reject(new RequestError(url, xhr.status, "TIMEOUT"));
+      reject(new RequestError(url, xhr.status, NetworkErrorTypes.TIMEOUT));
     };
+    if (connectionTimeout !== undefined) {
+      xhr.onreadystatechange = function clearConnectionTimeout() {
+        if (xhr.readyState >= XMLHttpRequest.HEADERS_RECEIVED) {
+          clearTimeout(connectionTimeoutId);
+        }
+      };
+    }
     if (onProgress !== undefined) {
       xhr.onprogress = function onXHRProgress(event) {
         var currentTime = getMonotonicTimeStamp();
@@ -28809,7 +28804,7 @@ function request(options) {
       };
     }
     xhr.onload = function onXHRLoad(event) {
-      if (xhr.readyState === 4) {
+      if (xhr.readyState === XMLHttpRequest.DONE) {
         clearCancellingProcess();
         if (xhr.status >= 200 && xhr.status < 300) {
           var receivedTime = getMonotonicTimeStamp();
@@ -28827,7 +28822,7 @@ function request(options) {
             responseData = xhr.response;
           }
           if (is_null_or_undefined_isNullOrUndefined(responseData)) {
-            reject(new RequestError(url, xhr.status, "PARSE_ERROR"));
+            reject(new RequestError(url, xhr.status, NetworkErrorTypes.PARSE_ERROR));
             return;
           }
           resolve({
@@ -28841,7 +28836,7 @@ function request(options) {
             responseData: responseData
           });
         } else {
-          reject(new RequestError(url, xhr.status, "ERROR_HTTP_CODE"));
+          reject(new RequestError(url, xhr.status, NetworkErrorTypes.ERROR_HTTP_CODE));
         }
       }
     };
@@ -28853,6 +28848,9 @@ function request(options) {
       if (timeoutId !== undefined) {
         clearTimeout(timeoutId);
       }
+      if (connectionTimeoutId !== undefined) {
+        clearTimeout(connectionTimeoutId);
+      }
       if (deregisterCancellationListener !== null) {
         deregisterCancellationListener();
       }
@@ -29129,6 +29127,7 @@ function generateRegularManifestLoader(preferredType) {
           url: url,
           responseType: "arraybuffer",
           timeout: loaderOptions.timeout,
+          connectionTimeout: loaderOptions.connectionTimeout,
           cancelSignal: cancelSignal
         });
       case "text":
@@ -29136,6 +29135,7 @@ function generateRegularManifestLoader(preferredType) {
           url: url,
           responseType: "text",
           timeout: loaderOptions.timeout,
+          connectionTimeout: loaderOptions.connectionTimeout,
           cancelSignal: cancelSignal
         });
       case "document":
@@ -29143,6 +29143,7 @@ function generateRegularManifestLoader(preferredType) {
           url: url,
           responseType: "document",
           timeout: loaderOptions.timeout,
+          connectionTimeout: loaderOptions.connectionTimeout,
           cancelSignal: cancelSignal
         });
       default:
@@ -30618,6 +30619,7 @@ function regularSegmentLoader(url, context, callbacks, loaderOptions, cancelSign
     responseType: "arraybuffer",
     headers: headers,
     timeout: loaderOptions.timeout,
+    connectionTimeout: loaderOptions.connectionTimeout,
     cancelSignal: cancelSignal,
     onProgress: callbacks.onProgress
   }).then(function (data) {
@@ -30993,6 +30995,7 @@ function constructSegmentUrl(wantedCdn, segment) {
           url: url,
           responseType: "text",
           timeout: loaderOptions.timeout,
+          connectionTimeout: loaderOptions.connectionTimeout,
           cancelSignal: cancelSignal,
           onProgress: callbacks.onProgress
         }).then(function (data) {
@@ -31006,6 +31009,7 @@ function constructSegmentUrl(wantedCdn, segment) {
           url: url,
           responseType: "arraybuffer",
           timeout: loaderOptions.timeout,
+          connectionTimeout: loaderOptions.connectionTimeout,
           cancelSignal: cancelSignal,
           onProgress: callbacks.onProgress
         }).then(function (data) {
@@ -31545,6 +31549,135 @@ function getMinimumAndMaximumPositions(periods) {
     maximumUnsafePosition: maxPositions.unsafe
   };
 }
+;// CONCATENATED MODULE: ./src/parsers/manifest/dash/common/manifest_bounds_calculator.ts
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * This class allows to easily calculate the first and last available positions
+ * in a content at any time.
+ *
+ * By centralizing the manifest bounds calculation in this class and by giving
+ * an instance of it to each parsed elements which might depend on it, we
+ * ensure that we can provide it once it is known to every one of those
+ * elements without needing to parse a second time the MPD.
+ * @class ManifestBoundsCalculator
+ */
+var ManifestBoundsCalculator = /*#__PURE__*/function () {
+  /**
+   * @param {Object} args
+   */
+  function ManifestBoundsCalculator(args) {
+    this._isDynamic = args.isDynamic;
+    this._timeShiftBufferDepth = !args.isDynamic || args.timeShiftBufferDepth === undefined ? null : args.timeShiftBufferDepth;
+    this._serverTimestampOffset = args.serverTimestampOffset;
+    this._availabilityStartTime = args.availabilityStartTime;
+  }
+  /**
+   * Set the last position and the position time (the value of the RxPlayer's
+   * monotonically-raising timestamp at the time that position was true
+   * converted into seconds).
+   *
+   * @example
+   * Example if you trust `Date.now()` to give you a reliable offset:
+   * ```js
+   * const lastPosition = Date.now();
+   * const positionTime = getMonotonicTimeStamp() / 1000;
+   * manifestBoundsCalculator.setLastPosition(lastPosition, positionTime);
+   * ```
+   *
+   * @param {number} lastPosition
+   * @param {number|undefined} positionTime
+   */
+  var _proto = ManifestBoundsCalculator.prototype;
+  _proto.setLastPosition = function setLastPosition(lastPosition, positionTime) {
+    this._lastPosition = lastPosition;
+    this._positionTime = positionTime;
+  }
+  /**
+   * Returns `true` if the last position and the position time
+   * (for dynamic content only) have been comunicated.
+   * `false` otherwise.
+   * @returns {boolean}
+   */;
+  _proto.lastPositionIsKnown = function lastPositionIsKnown() {
+    if (this._isDynamic) {
+      return this._positionTime != null && this._lastPosition != null;
+    }
+    return this._lastPosition != null;
+  }
+  /**
+   * Estimate a minimum bound for the content from the last set segment time
+   * and buffer depth.
+   * Consider that it is only an estimation, not the real value.
+   * @return {number|undefined}
+   */;
+  _proto.getEstimatedMinimumSegmentTime = function getEstimatedMinimumSegmentTime() {
+    var _a;
+    if (!this._isDynamic || this._timeShiftBufferDepth === null) {
+      return 0;
+    }
+    var maximumBound = (_a = this.getEstimatedLiveEdge()) !== null && _a !== void 0 ? _a : this.getEstimatedMaximumPosition(0);
+    if (maximumBound === undefined) {
+      return undefined;
+    }
+    var minimumBound = maximumBound - this._timeShiftBufferDepth;
+    return minimumBound;
+  }
+  /**
+   * Estimate the segment time in seconds that corresponds to what could be
+   * considered the live edge (or `undefined` for non-live contents).
+   *
+   * Note that for some contents which just anounce segments in advance, this
+   * value might be very different than the maximum position that is
+   * requestable.
+   * @return {number|undefined}
+   */;
+  _proto.getEstimatedLiveEdge = function getEstimatedLiveEdge() {
+    if (!this._isDynamic || this._serverTimestampOffset === undefined) {
+      return undefined;
+    }
+    return (getMonotonicTimeStamp() + this._serverTimestampOffset) / 1000 - this._availabilityStartTime;
+  }
+  /**
+   * Produce a rough estimate of the ending time of the last requestable segment
+   * in that content.
+   *
+   * This value is only an estimate and may be far from reality.
+   *
+   * The `availabilityTimeOffset` in argument is the corresponding
+   * `availabilityTimeOffset` that applies to the current wanted segment, or `0`
+   * if none exist. It will be applied on live content to deduce the maximum
+   * segment time available.
+   */;
+  _proto.getEstimatedMaximumPosition = function getEstimatedMaximumPosition(availabilityTimeOffset) {
+    if (!this._isDynamic) {
+      return this._lastPosition;
+    }
+    var liveEdge = this.getEstimatedLiveEdge();
+    if (liveEdge !== undefined && availabilityTimeOffset !== Infinity) {
+      return liveEdge + availabilityTimeOffset;
+    } else if (this._positionTime !== undefined && this._lastPosition !== undefined) {
+      return Math.max(this._lastPosition - this._positionTime + getMonotonicTimeStamp() / 1000, 0);
+    }
+    return this._lastPosition;
+  };
+  return ManifestBoundsCalculator;
+}();
+
 ;// CONCATENATED MODULE: ./src/parsers/manifest/dash/common/parse_availability_start_time.ts
 /**
  * Copyright 2015 CANAL+ Group
@@ -31679,6 +31812,11 @@ function flattenOverlappingPeriods(parsedPeriods) {
         // `lastFlattenedPeriod` has now a negative or `0` duration.
         // Remove it, consider the next Period in its place, and re-start the loop.
         flattenedPeriods.pop();
+        if (flattenedPeriods.length === 0) {
+          // There's no remaining Period to compare to `parsedPeriod`
+          break;
+        }
+        // Take the previous Period as reference and compare it now to `parsedPeriod`
         lastFlattenedPeriod = flattenedPeriods[flattenedPeriods.length - 1];
       }
     }
@@ -31746,115 +31884,6 @@ function getPeriodsTimeInformation(periodsIR, manifestInfos) {
   });
   return periodsTimeInformation;
 }
-;// CONCATENATED MODULE: ./src/parsers/manifest/dash/common/manifest_bounds_calculator.ts
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/**
- * This class allows to easily calculate the first and last available positions
- * in a content at any time.
- *
- * That task can be an hard for dynamic DASH contents: it depends on a
- * `timeShiftBufferDepth` defined in the MPD and on the maximum possible
- * position.
- *
- * The latter can come from either a clock synchronization mechanism or the
- * indexing schemes (e.g. SegmentTemplate, SegmentTimeline etc.) of the last
- * Periods.
- * As such, it might only be known once a large chunk of the MPD has already
- * been parsed.
- *
- * By centralizing the manifest bounds calculation in this class and by giving
- * an instance of it to each parsed elements which might depend on it, we
- * ensure that we can provide it once it is known to every one of those
- * elements without needing to parse a second time the MPD.
- * @class ManifestBoundsCalculator
- */
-var ManifestBoundsCalculator = /*#__PURE__*/function () {
-  /**
-   * @param {Object} args
-   */
-  function ManifestBoundsCalculator(args) {
-    this._isDynamic = args.isDynamic;
-    this._timeShiftBufferDepth = !args.isDynamic || args.timeShiftBufferDepth === undefined ? null : args.timeShiftBufferDepth;
-  }
-  /**
-   * Set the last position and the position time (the value of the RxPlayer's
-   * monotonically-raising timestamp at the time that position was true
-   * converted into seconds).
-   *
-   * @example
-   * Example if you trust `Date.now()` to give you a reliable offset:
-   * ```js
-   * const lastPosition = Date.now();
-   * const positionTime = getMonotonicTimeStamp() / 1000;
-   * manifestBoundsCalculator.setLastPosition(lastPosition, positionTime);
-   * ```
-   *
-   * @param {number} lastPosition
-   * @param {number|undefined} positionTime
-   */
-  var _proto = ManifestBoundsCalculator.prototype;
-  _proto.setLastPosition = function setLastPosition(lastPosition, positionTime) {
-    this._lastPosition = lastPosition;
-    this._positionTime = positionTime;
-  }
-  /**
-   * Returns `true` if the last position and the position time
-   * (for dynamic content only) have been comunicated.
-   * `false` otherwise.
-   * @returns {boolean}
-   */;
-  _proto.lastPositionIsKnown = function lastPositionIsKnown() {
-    if (this._isDynamic) {
-      return this._positionTime != null && this._lastPosition != null;
-    }
-    return this._lastPosition != null;
-  }
-  /**
-   * Estimate a minimum bound for the content from the last set segment time
-   * and buffer depth.
-   * Consider that it is only an estimation, not the real value.
-   * @return {number|undefined}
-   */;
-  _proto.estimateMinimumBound = function estimateMinimumBound() {
-    if (!this._isDynamic || this._timeShiftBufferDepth === null) {
-      return 0;
-    }
-    var maximumBound = this.estimateMaximumBound();
-    if (maximumBound === undefined) {
-      return undefined;
-    }
-    var minimumBound = maximumBound - this._timeShiftBufferDepth;
-    return minimumBound;
-  }
-  /**
-   * Estimate a maximum bound for the content from the last set segment time.
-   * Consider that it is only an estimation, not the real value.
-   * @return {number|undefined}
-   */;
-  _proto.estimateMaximumBound = function estimateMaximumBound() {
-    if (this._isDynamic && this._positionTime != null && this._lastPosition != null) {
-      return Math.max(this._lastPosition - this._positionTime + getMonotonicTimeStamp() / 1000, 0);
-    }
-    return this._lastPosition;
-  };
-  return ManifestBoundsCalculator;
-}();
-
 ;// CONCATENATED MODULE: ./src/parsers/manifest/dash/common/attach_trickmode_track.ts
 function attach_trickmode_track_createForOfIteratorHelperLoose(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (it) return (it = it.call(o)).next.bind(it); if (Array.isArray(o) || (it = attach_trickmode_track_unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
 function attach_trickmode_track_unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return attach_trickmode_track_arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return attach_trickmode_track_arrayLikeToArray(o, minLen); }
@@ -32019,6 +32048,31 @@ function inferAdaptationType(representations, adaptationMimeType, adaptationCode
   }
   return undefined;
 }
+;// CONCATENATED MODULE: ./src/parsers/manifest/dash/common/convert_supplemental_codecs.ts
+
+var supplementalCodecSeparator = /[, ]+/g;
+/**
+ * Converts SCTE 214 supplemental codec string into RFC4281 codec string
+ *
+ * The returned value is a codec string respecting RFC6381
+ *
+ * SCTE 214 defines supplemental codecs as a whitespace-separated multiple list of
+ * codec strings
+ *
+ * RFC6381 defines codecs as a comma-separated list of codec strings.
+ *
+ * This two syntax differs and this parser is used to convert SCTE214
+ * to be compliant with what MSE APIs expect
+ *
+ * @param {string} val - The codec string to parse
+ * @returns { Array.<string | undefined | null>}
+ */
+function convertSupplementalCodecsToRFC6381(val) {
+  if (isNonEmptyString(val)) {
+    return val.trim().replace(supplementalCodecSeparator, ", ");
+  }
+  return "";
+}
 ;// CONCATENATED MODULE: ./src/parsers/manifest/dash/common/get_hdr_information.ts
 /**
  * Copyright 2015 CANAL+ Group
@@ -32261,13 +32315,17 @@ function getWantedRepeatIndex(segmentStartTime, segmentDuration, wantedTime) {
  * @param {Object} index - index object, constructed by parsing the manifest.
  * @param {number} from - starting timestamp wanted, in seconds
  * @param {number} durationWanted - duration wanted, in seconds
+ * @param {Object} manifestBoundsCalculator
+ * @param {number|undefined} scaledPeriodEnd
  * @param {function} isEMSGWhitelisted
- * @param {number|undefined} maximumTime
  * @returns {Array.<Object>}
  */
-function getSegmentsFromTimeline(index, from, durationWanted, isEMSGWhitelisted, maximumTime) {
+function getSegmentsFromTimeline(index, from, durationWanted, manifestBoundsCalculator, scaledPeriodEnd, isEMSGWhitelisted) {
+  var _a;
+  var maximumTime = manifestBoundsCalculator.getEstimatedMaximumPosition((_a = index.availabilityTimeOffset) !== null && _a !== void 0 ? _a : 0);
+  var wantedMaximum = Math.min(from + durationWanted, maximumTime !== null && maximumTime !== void 0 ? maximumTime : Infinity);
   var scaledUp = toIndexTime(from, index);
-  var scaledTo = toIndexTime(from + durationWanted, index);
+  var scaledTo = toIndexTime(wantedMaximum, index);
   var timeline = index.timeline,
     timescale = index.timescale,
     segmentUrlTemplate = index.segmentUrlTemplate,
@@ -32281,7 +32339,13 @@ function getSegmentsFromTimeline(index, from, durationWanted, isEMSGWhitelisted,
     var duration = timelineItem.duration,
       start = timelineItem.start,
       range = timelineItem.range;
-    var repeat = calculateRepeat(timelineItem, timeline[i + 1], maximumTime);
+    var maxRepeatTime = void 0;
+    if (maximumTime === undefined) {
+      maxRepeatTime = scaledPeriodEnd;
+    } else {
+      maxRepeatTime = Math.min(maximumTime * timescale, scaledPeriodEnd !== null && scaledPeriodEnd !== void 0 ? scaledPeriodEnd : Infinity);
+    }
+    var repeat = calculateRepeat(timelineItem, timeline[i + 1], maxRepeatTime);
     var complete = index.availabilityTimeComplete !== false || i !== timelineLength - 1 && repeat !== 0;
     var segmentNumberInCurrentRange = getWantedRepeatIndex(start, duration, scaledUp);
     var segmentTime = start + segmentNumberInCurrentRange * duration;
@@ -32414,6 +32478,7 @@ var BaseRepresentationIndex = /*#__PURE__*/function () {
       timeline: (_c = index.timeline) !== null && _c !== void 0 ? _c : [],
       timescale: timescale
     };
+    this._manifestBoundsCalculator = context.manifestBoundsCalculator;
     this._scaledPeriodStart = toIndexTime(periodStart, this._index);
     this._scaledPeriodEnd = periodEnd == null ? undefined : toIndexTime(periodEnd, this._index);
     this._isInitialized = this._index.timeline.length > 0;
@@ -32442,7 +32507,7 @@ var BaseRepresentationIndex = /*#__PURE__*/function () {
    * @returns {Array.<Object>}
    */;
   _proto.getSegments = function getSegments(from, dur) {
-    return getSegmentsFromTimeline(this._index, from, dur, this._isEMSGWhitelisted, this._scaledPeriodEnd);
+    return getSegmentsFromTimeline(this._index, from, dur, this._manifestBoundsCalculator, this._scaledPeriodEnd, this._isEMSGWhitelisted);
   }
   /**
    * Returns false as no Segment-Base based index should need to be refreshed.
@@ -32526,8 +32591,8 @@ var BaseRepresentationIndex = /*#__PURE__*/function () {
    * should become available in the future.
    * @returns {Boolean}
    */;
-  _proto.isFinished = function isFinished() {
-    return true;
+  _proto.isStillAwaitingFutureSegments = function isStillAwaitingFutureSegments() {
+    return false;
   }
   /**
    * No segment in a `BaseRepresentationIndex` are known initially.
@@ -32783,8 +32848,8 @@ var ListRepresentationIndex = /*#__PURE__*/function () {
   /**
    * @returns {Boolean}
    */;
-  _proto.isFinished = function isFinished() {
-    return true;
+  _proto.isStillAwaitingFutureSegments = function isStillAwaitingFutureSegments() {
+    return false;
   }
   /**
    * @returns {Boolean}
@@ -33230,9 +33295,13 @@ function constructTimelineFromPreviousTimeline(newElements, prevTimeline) {
 
 
 
-
 // eslint-disable-next-line max-len
 
+/**
+ * `IRepresentationIndex` implementation for a DASH `SegmentTimeline` segment
+ * indexing scheme.
+ * @class TimelineRepresentationIndex
+ */
 var TimelineRepresentationIndex = /*#__PURE__*/function () {
   /**
    * @param {Object} index
@@ -33244,6 +33313,7 @@ var TimelineRepresentationIndex = /*#__PURE__*/function () {
       throw new Error("The given index is not compatible with a " + "TimelineRepresentationIndex.");
     }
     var availabilityTimeComplete = context.availabilityTimeComplete,
+      availabilityTimeOffset = context.availabilityTimeOffset,
       manifestBoundsCalculator = context.manifestBoundsCalculator,
       isDynamic = context.isDynamic,
       isLastPeriod = context.isLastPeriod,
@@ -33270,8 +33340,25 @@ var TimelineRepresentationIndex = /*#__PURE__*/function () {
     this._parseTimeline = (_b = index.timelineParser) !== null && _b !== void 0 ? _b : null;
     var initializationUrl = ((_c = index.initialization) === null || _c === void 0 ? void 0 : _c.media) === undefined ? null : constructRepresentationUrl(index.initialization.media, representationId, representationBitrate);
     var segmentUrlTemplate = index.media === undefined ? null : constructRepresentationUrl(index.media, representationId, representationBitrate);
+    var actualAvailabilityTimeOffset;
+    // Technically, it seems (although it is not clear) that an MPD may contain
+    // future segments and it's the job of a player to not request segments later
+    // than the time at which they should be available.
+    // In practice, we don't do that for various reasons: precision issues,
+    // various DASH spec interpretations by packagers and players...
+    //
+    // So as a compromise, if nothing in the MPD indicates that future segments
+    // may be announced (see code below), we will act as if ALL segments in this
+    // TimelineRepresentationIndex are requestable
+    if (availabilityTimeOffset === undefined && availabilityTimeComplete === undefined) {
+      actualAvailabilityTimeOffset = Infinity; // Meaning: we can request
+      // everything in the index
+    } else {
+      actualAvailabilityTimeOffset = availabilityTimeOffset !== null && availabilityTimeOffset !== void 0 ? availabilityTimeOffset : 0;
+    }
     this._index = {
-      availabilityTimeComplete: availabilityTimeComplete,
+      availabilityTimeComplete: availabilityTimeComplete !== null && availabilityTimeComplete !== void 0 ? availabilityTimeComplete : true,
+      availabilityTimeOffset: actualAvailabilityTimeOffset,
       indexRange: index.indexRange,
       indexTimeOffset: indexTimeOffset,
       initialization: index.initialization == null ? undefined : {
@@ -33321,7 +33408,7 @@ var TimelineRepresentationIndex = /*#__PURE__*/function () {
       timeline: timeline,
       timescale: timescale,
       indexTimeOffset: indexTimeOffset
-    }, from, duration, this._isEMSGWhitelisted, this._scaledPeriodEnd);
+    }, from, duration, this._manifestBoundsCalculator, this._scaledPeriodEnd, this._isEMSGWhitelisted);
   }
   /**
    * Returns true if the index should be refreshed.
@@ -33353,12 +33440,19 @@ var TimelineRepresentationIndex = /*#__PURE__*/function () {
    * @returns {Number|null}
    */;
   _proto.getLastAvailablePosition = function getLastAvailablePosition() {
+    var _a;
     this._refreshTimeline();
     if (this._index.timeline === null) {
       this._index.timeline = this._getTimeline();
     }
-    var lastTime = TimelineRepresentationIndex.getIndexEnd(this._index.timeline, this._scaledPeriodEnd);
-    return lastTime === null ? null : fromIndexTime(lastTime, this._index);
+    var lastReqSegInfo = getLastRequestableSegmentInfo(
+    // Needed typecast for TypeScript
+    this._index, this._manifestBoundsCalculator, this._scaledPeriodEnd);
+    if (lastReqSegInfo === null) {
+      return null;
+    }
+    var lastScaledPosition = Math.min(lastReqSegInfo.end, (_a = this._scaledPeriodEnd) !== null && _a !== void 0 ? _a : Infinity);
+    return fromIndexTime(lastScaledPosition, this._index);
   }
   /**
    * Returns the absolute end in seconds this RepresentationIndex can reach once
@@ -33366,11 +33460,20 @@ var TimelineRepresentationIndex = /*#__PURE__*/function () {
    * @returns {number|null|undefined}
    */;
   _proto.getEnd = function getEnd() {
-    if (!this._isDynamic || !this._isLastPeriod) {
-      // @see isFinished
-      return this.getLastAvailablePosition();
+    var _a;
+    if (this._isDynamic && !this._isLastPeriod) {
+      return undefined;
     }
-    return undefined;
+    this._refreshTimeline();
+    if (this._index.timeline === null) {
+      this._index.timeline = this._getTimeline();
+    }
+    if (this._index.timeline.length <= 0) {
+      return null;
+    }
+    var lastSegment = this._index.timeline[this._index.timeline.length - 1];
+    var lastTime = Math.min(getIndexSegmentEnd(lastSegment, null, this._scaledPeriodEnd), (_a = this._scaledPeriodEnd) !== null && _a !== void 0 ? _a : Infinity);
+    return fromIndexTime(lastTime, this._index);
   }
   /**
    * Returns:
@@ -33384,34 +33487,56 @@ var TimelineRepresentationIndex = /*#__PURE__*/function () {
    * @returns {boolean|undefined}
    */;
   _proto.awaitSegmentBetween = function awaitSegmentBetween(start, end) {
-    var _a;
+    var _a, _b;
     assert_assert(start <= end);
-    if (!this._isDynamic || !this._isLastPeriod) {
-      return false;
+    if (!this._isDynamic) {
+      return false; // No segment will be newly available in the future
     }
+
     this._refreshTimeline();
     if (this._index.timeline === null) {
       this._index.timeline = this._getTimeline();
     }
     var _this$_index2 = this._index,
-      timeline = _this$_index2.timeline,
-      timescale = _this$_index2.timescale;
+      timescale = _this$_index2.timescale,
+      timeline = _this$_index2.timeline;
     var segmentTimeRounding = getSegmentTimeRoundingError(timescale);
-    var scaledEnd = toIndexTime(end, this._index);
-    if (timeline.length > 0) {
-      var lastTimelineElement = timeline[timeline.length - 1];
-      var lastSegmentEnd = getIndexSegmentEnd(lastTimelineElement, null, this._scaledPeriodEnd);
-      var roundedEnd = lastSegmentEnd + segmentTimeRounding;
-      if (roundedEnd >= Math.min(scaledEnd, (_a = this._scaledPeriodEnd) !== null && _a !== void 0 ? _a : Infinity)) {
-        return false; // already loaded
+    var scaledWantedEnd = toIndexTime(end, this._index);
+    var lastReqSegInfo = getLastRequestableSegmentInfo(
+    // Needed typecast for TypeScript
+    this._index, this._manifestBoundsCalculator, this._scaledPeriodEnd);
+    if (lastReqSegInfo !== null) {
+      var lastReqSegmentEnd = Math.min(lastReqSegInfo.end, (_a = this._scaledPeriodEnd) !== null && _a !== void 0 ? _a : Infinity);
+      var roundedReqSegmentEnd = lastReqSegmentEnd + segmentTimeRounding;
+      if (roundedReqSegmentEnd >= Math.min(scaledWantedEnd, (_b = this._scaledPeriodEnd) !== null && _b !== void 0 ? _b : Infinity)) {
+        return false; // everything up to that point is already requestable
       }
     }
 
+    var scaledWantedStart = toIndexTime(start, this._index);
+    if (timeline.length > 0 && lastReqSegInfo !== null && !lastReqSegInfo.isLastOfTimeline) {
+      // There are some future segments already anounced in the MPD
+      var lastSegment = timeline[timeline.length - 1];
+      var lastSegmentEnd = getIndexSegmentEnd(lastSegment, null, this._scaledPeriodEnd);
+      var roundedLastSegEnd = lastSegmentEnd + segmentTimeRounding;
+      if (scaledWantedStart < roundedLastSegEnd + segmentTimeRounding) {
+        return true; // The MPD's timeline already contains one such element,
+        // It is just not requestable yet
+      }
+    }
+
+    if (!this._isLastPeriod) {
+      // Let's consider - perhaps wrongly, that Periods which aren't the last
+      // one have all of their segments announced.
+      return false;
+    }
     if (this._scaledPeriodEnd === undefined) {
-      return scaledEnd + segmentTimeRounding > this._scaledPeriodStart ? undefined : false;
+      return scaledWantedEnd + segmentTimeRounding > this._scaledPeriodStart ? undefined :
+      // There may be future segments at this point
+      false; // Before the current Period
     }
-    var scaledStart = toIndexTime(start, this._index);
-    return scaledStart - segmentTimeRounding < this._scaledPeriodEnd && scaledEnd + segmentTimeRounding > this._scaledPeriodStart;
+    // `true` if within the boundaries of this Period. `false` otherwise.
+    return scaledWantedStart - segmentTimeRounding < this._scaledPeriodEnd && scaledWantedEnd + segmentTimeRounding > this._scaledPeriodStart;
   }
   /**
    * Returns true if a Segment returned by this index is still considered
@@ -33429,11 +33554,9 @@ var TimelineRepresentationIndex = /*#__PURE__*/function () {
     if (this._index.timeline === null) {
       this._index.timeline = this._getTimeline();
     }
-    var _this$_index3 = this._index,
-      timeline = _this$_index3.timeline,
-      timescale = _this$_index3.timescale,
-      indexTimeOffset = _this$_index3.indexTimeOffset;
-    return is_segment_still_available_isSegmentStillAvailable(segment, timeline, timescale, indexTimeOffset);
+    return _isSegmentStillAvailable(segment,
+    // Needed typecast for TypeScript
+    this._index, this._manifestBoundsCalculator, this._scaledPeriodEnd);
   }
   /**
    * Checks if the time given is in a discontinuity. That is:
@@ -33497,6 +33620,8 @@ var TimelineRepresentationIndex = /*#__PURE__*/function () {
     if (hasReplaced) {
       this._index.startNumber = newIndex._index.startNumber;
     }
+    this._index.availabilityTimeOffset = newIndex._index.availabilityTimeOffset;
+    this._index.availabilityTimeComplete = newIndex._index.availabilityTimeComplete;
     this._index.endNumber = newIndex._index.endNumber;
     this._isDynamic = newIndex._isDynamic;
     this._scaledPeriodStart = newIndex._scaledPeriodStart;
@@ -33505,32 +33630,66 @@ var TimelineRepresentationIndex = /*#__PURE__*/function () {
     this._isLastPeriod = newIndex._isLastPeriod;
   }
   /**
-   * Returns `true` if this RepresentationIndex currently contains its last
+   * Returns `false` if this RepresentationIndex currently contains its last
    * segment.
-   * Returns `false` if it's still pending.
+   * Returns `true` if it's still pending.
    * @returns {Boolean}
    */;
-  _proto.isFinished = function isFinished() {
-    if (!this._isDynamic || !this._isLastPeriod) {
-      // Either the content is not dynamic, in which case no new segment will
-      // be generated, either it is but this index is not linked to the current
-      // last Period in the MPD, in which case it is inferred that it has been
-      // completely generated. Note that this second condition might break very
-      // very rare use cases where old Periods are still being generated, yet it
-      // should fix more cases than it breaks.
-      return true;
+  _proto.isStillAwaitingFutureSegments = function isStillAwaitingFutureSegments() {
+    var _a;
+    if (!this._isDynamic) {
+      return false;
     }
+    this._refreshTimeline();
     if (this._index.timeline === null) {
       this._index.timeline = this._getTimeline();
     }
     var timeline = this._index.timeline;
-    if (this._scaledPeriodEnd === undefined || timeline.length === 0) {
-      return false;
+    if (timeline.length === 0) {
+      // No segment announced in this Period
+      if (this._scaledPeriodEnd !== undefined) {
+        var liveEdge = this._manifestBoundsCalculator.getEstimatedLiveEdge();
+        if (liveEdge !== undefined && toIndexTime(liveEdge, this._index) > this._scaledPeriodEnd) {
+          // This Period is over, we're not awaiting anything
+          return false;
+        }
+      }
+      // Let's just consider that we're awaiting only for when this is the last Period.
+      return this._isLastPeriod;
     }
-    var lastTimelineElement = timeline[timeline.length - 1];
-    var lastTime = getIndexSegmentEnd(lastTimelineElement, null, this._scaledPeriodEnd);
     var segmentTimeRounding = getSegmentTimeRoundingError(this._index.timescale);
-    return lastTime + segmentTimeRounding >= this._scaledPeriodEnd;
+    var lastReqSegInfo = getLastRequestableSegmentInfo(
+    // Needed typecast for TypeScript
+    this._index, this._manifestBoundsCalculator, this._scaledPeriodEnd);
+    if (lastReqSegInfo !== null && !lastReqSegInfo.isLastOfTimeline) {
+      // There might be non-yet requestable segments in the manifest
+      var lastReqSegmentEnd = Math.min(lastReqSegInfo.end, (_a = this._scaledPeriodEnd) !== null && _a !== void 0 ? _a : Infinity);
+      if (this._scaledPeriodEnd !== undefined && lastReqSegmentEnd + segmentTimeRounding >= this._scaledPeriodEnd) {
+        // The last requestable segment ends after the end of the Period anyway
+        return false;
+      }
+      return true; // There are not-yet requestable segments
+    }
+
+    if (!this._isLastPeriod) {
+      // This index is not linked to the current last Period in the MPD, in
+      // which case it is inferred that all segments have been announced.
+      //
+      // Note that this condition might break very very rare use cases where old
+      // Periods are still being generated, yet it should fix more cases than it
+      // breaks.
+      return false;
+    }
+    if (this._scaledPeriodEnd === undefined) {
+      // This is the last Period of a dynamic content whose end is unknown.
+      // Just return true.
+      return true;
+    }
+    var lastSegment = timeline[timeline.length - 1];
+    var lastSegmentEnd = getIndexSegmentEnd(lastSegment, null, this._scaledPeriodEnd);
+    // We're awaiting future segments only if the current end is before the end
+    // of the Period
+    return lastSegmentEnd + segmentTimeRounding < this._scaledPeriodEnd;
   }
   /**
    * @returns {Boolean}
@@ -33564,7 +33723,7 @@ var TimelineRepresentationIndex = /*#__PURE__*/function () {
     if (!this._isDynamic) {
       return;
     }
-    var firstPosition = this._manifestBoundsCalculator.estimateMinimumBound();
+    var firstPosition = this._manifestBoundsCalculator.getEstimatedMinimumSegmentTime();
     if (firstPosition == null) {
       return; // we don't know yet
     }
@@ -33576,12 +33735,6 @@ var TimelineRepresentationIndex = /*#__PURE__*/function () {
     } else if (this._index.endNumber !== undefined) {
       this._index.startNumber = nbEltsRemoved + 1;
     }
-  };
-  TimelineRepresentationIndex.getIndexEnd = function getIndexEnd(timeline, scaledPeriodEnd) {
-    if (timeline.length <= 0) {
-      return null;
-    }
-    return Math.min(getIndexSegmentEnd(timeline[timeline.length - 1], null, scaledPeriodEnd), scaledPeriodEnd !== null && scaledPeriodEnd !== void 0 ? scaledPeriodEnd : Infinity);
   }
   /**
    * Allows to generate the "timeline" for this RepresentationIndex.
@@ -33670,6 +33823,113 @@ function updateTimelineFromEndNumber(timeline, startNumber, endNumber) {
   }
   return timeline;
 }
+/**
+ * Returns true if a Segment returned by the corresponding index is still
+ * considered available.
+ * Returns false if it is not available anymore.
+ * Returns undefined if we cannot know whether it is still available or not.
+ * /!\ We do not check the mediaURLs of the segment.
+ * @param {Object} segment
+ * @param {Object} index
+ * @param {Object} manifestBoundsCalculator
+ * @param {number|undefined} scaledPeriodEnd
+ * @returns {Boolean|undefined}
+ */
+function _isSegmentStillAvailable(segment, index, manifestBoundsCalculator, scaledPeriodEnd) {
+  var lastReqSegInfo = getLastRequestableSegmentInfo(index, manifestBoundsCalculator, scaledPeriodEnd);
+  if (lastReqSegInfo === null) {
+    return false;
+  }
+  for (var i = 0; i < index.timeline.length; i++) {
+    if (lastReqSegInfo.timelineIdx < i) {
+      return false;
+    }
+    var tSegment = index.timeline[i];
+    var tSegmentTime = (tSegment.start - index.indexTimeOffset) / index.timescale;
+    if (tSegmentTime > segment.time) {
+      return false; // We went over it without finding it
+    } else if (tSegmentTime === segment.time) {
+      if (tSegment.range === undefined) {
+        return segment.range === undefined;
+      }
+      return segment.range != null && tSegment.range[0] === segment.range[0] && tSegment.range[1] === segment.range[1];
+    } else {
+      // tSegment.start < segment.time
+      if (tSegment.repeatCount >= 0 && tSegment.duration !== undefined) {
+        var timeDiff = tSegmentTime - tSegment.start;
+        var repeat = timeDiff / tSegment.duration - 1;
+        return repeat % 1 === 0 && repeat <= lastReqSegInfo.newRepeatCount;
+      }
+    }
+  }
+  return false;
+}
+/**
+ * Returns from the given RepresentationIndex information on the last segment
+ * that may be requested currently.
+ *
+ * Returns `null` if there's no such segment.
+ * @param {Object} index
+ * @param {Object} manifestBoundsCalculator
+ * @param {number|undefined} scaledPeriodEnd
+ * @returns {number|null}
+ */
+
+function getLastRequestableSegmentInfo(index, manifestBoundsCalculator, scaledPeriodEnd) {
+  if (index.timeline.length <= 0) {
+    return null;
+  }
+  if (index.availabilityTimeOffset === Infinity) {
+    // availabilityTimeOffset to Infinity == Everything is requestable in the timeline.
+    var lastIndex = index.timeline.length - 1;
+    var lastElem = index.timeline[lastIndex];
+    return {
+      isLastOfTimeline: true,
+      timelineIdx: lastIndex,
+      newRepeatCount: lastElem.repeatCount,
+      end: getIndexSegmentEnd(lastElem, null, scaledPeriodEnd)
+    };
+  }
+  var adjustedMaxSeconds = manifestBoundsCalculator.getEstimatedMaximumPosition(index.availabilityTimeOffset);
+  if (adjustedMaxSeconds === undefined) {
+    var _lastIndex = index.timeline.length - 1;
+    var _lastElem = index.timeline[_lastIndex];
+    return {
+      isLastOfTimeline: true,
+      timelineIdx: _lastIndex,
+      newRepeatCount: _lastElem.repeatCount,
+      end: getIndexSegmentEnd(_lastElem, null, scaledPeriodEnd)
+    };
+  }
+  for (var i = index.timeline.length - 1; i >= index.timeline.length; i--) {
+    var element = index.timeline[i];
+    var endOfFirstOccurence = element.start + element.duration;
+    if (fromIndexTime(endOfFirstOccurence, index) <= adjustedMaxSeconds) {
+      var endTime = getIndexSegmentEnd(element, index.timeline[i + 1], scaledPeriodEnd);
+      if (fromIndexTime(endTime, index) <= adjustedMaxSeconds) {
+        return {
+          isLastOfTimeline: i === index.timeline.length - 1,
+          timelineIdx: i,
+          newRepeatCount: element.repeatCount,
+          end: endOfFirstOccurence
+        };
+      } else {
+        // We have to find the right repeatCount
+        var maxIndexTime = toIndexTime(adjustedMaxSeconds, index);
+        var diffToSegStart = maxIndexTime - element.start;
+        var nbOfSegs = Math.floor(diffToSegStart / element.duration);
+        assert_assert(nbOfSegs >= 1);
+        return {
+          isLastOfTimeline: false,
+          timelineIdx: i,
+          newRepeatCount: nbOfSegs - 1,
+          end: element.start + nbOfSegs * element.duration
+        };
+      }
+    }
+  }
+  return null;
+}
 ;// CONCATENATED MODULE: ./src/parsers/manifest/dash/common/indexes/timeline/index.ts
 /**
  * Copyright 2015 CANAL+ Group
@@ -33899,13 +34159,22 @@ var TemplateRepresentationIndex = /*#__PURE__*/function () {
     var timescale = this._index.timescale;
     var segmentTimeRounding = getSegmentTimeRoundingError(timescale);
     var scaledPeriodStart = this._periodStart * timescale;
+    var scaledRelativeStart = start * timescale - scaledPeriodStart;
     var scaledRelativeEnd = end * timescale - scaledPeriodStart;
+    var lastSegmentStart = this._getLastSegmentStart();
+    if (is_null_or_undefined_isNullOrUndefined(lastSegmentStart)) {
+      var _relativeScaledIndexEnd = this._estimateRelativeScaledEnd();
+      if (_relativeScaledIndexEnd === undefined) {
+        return scaledRelativeEnd + segmentTimeRounding >= 0;
+      }
+      return scaledRelativeEnd + segmentTimeRounding >= 0 && scaledRelativeStart < _relativeScaledIndexEnd - segmentTimeRounding;
+    }
+    var lastSegmentEnd = lastSegmentStart + this._index.duration;
     var relativeScaledIndexEnd = this._estimateRelativeScaledEnd();
     if (relativeScaledIndexEnd === undefined) {
-      return scaledRelativeEnd + segmentTimeRounding >= 0;
+      return scaledRelativeEnd > lastSegmentEnd - segmentTimeRounding;
     }
-    var scaledRelativeStart = start * timescale - scaledPeriodStart;
-    return scaledRelativeStart - segmentTimeRounding < relativeScaledIndexEnd;
+    return scaledRelativeEnd > lastSegmentEnd - segmentTimeRounding && scaledRelativeStart < relativeScaledIndexEnd - segmentTimeRounding;
   }
   /**
    * Returns true if, based on the arguments, the index should be refreshed.
@@ -33948,30 +34217,30 @@ var TemplateRepresentationIndex = /*#__PURE__*/function () {
     return false;
   }
   /**
-   * Returns `true` if the last segments in this index have already been
+   * Returns `false` if the last segments in this index have already been
    * generated so that we can freely go to the next period.
-   * Returns `false` if the index is still waiting on future segments to be
+   * Returns `true` if the index is still waiting on future segments to be
    * generated.
    * @returns {Boolean}
    */;
-  _proto.isFinished = function isFinished() {
+  _proto.isStillAwaitingFutureSegments = function isStillAwaitingFutureSegments() {
     if (!this._isDynamic) {
-      return true;
+      return false;
     }
     var scaledRelativeIndexEnd = this._estimateRelativeScaledEnd();
     if (scaledRelativeIndexEnd === undefined) {
-      return false;
+      return true;
     }
     var timescale = this._index.timescale;
     var lastSegmentStart = this._getLastSegmentStart();
     // As last segment start is null if live time is before
     // current period, consider the index not to be finished.
     if (is_null_or_undefined_isNullOrUndefined(lastSegmentStart)) {
-      return false;
+      return true;
     }
     var lastSegmentEnd = lastSegmentStart + this._index.duration;
     var segmentTimeRounding = getSegmentTimeRoundingError(timescale);
-    return lastSegmentEnd + segmentTimeRounding >= scaledRelativeIndexEnd;
+    return lastSegmentEnd + segmentTimeRounding < scaledRelativeIndexEnd;
   }
   /**
    * @returns {Boolean}
@@ -34009,6 +34278,7 @@ var TemplateRepresentationIndex = /*#__PURE__*/function () {
    * @returns {number | null | undefined}
    */;
   _proto._getFirstSegmentStart = function _getFirstSegmentStart() {
+    var _a;
     if (!this._isDynamic) {
       return 0; // it is the start of the Period
     }
@@ -34017,8 +34287,8 @@ var TemplateRepresentationIndex = /*#__PURE__*/function () {
       // /!\ The scaled max position augments continuously and might not
       // reflect exactly the real server-side value. As segments are
       // generated discretely.
-      var maximumBound = this._manifestBoundsCalculator.estimateMaximumBound();
-      if (maximumBound !== undefined && maximumBound < this._periodStart) {
+      var maximumSegmentTime = this._manifestBoundsCalculator.getEstimatedMaximumPosition((_a = this._availabilityTimeOffset) !== null && _a !== void 0 ? _a : 0);
+      if (maximumSegmentTime !== undefined && maximumSegmentTime < this._periodStart) {
         // Maximum position is before this period.
         // No segment is yet available here
         return null;
@@ -34027,7 +34297,7 @@ var TemplateRepresentationIndex = /*#__PURE__*/function () {
     var _this$_index = this._index,
       duration = _this$_index.duration,
       timescale = _this$_index.timescale;
-    var firstPosition = this._manifestBoundsCalculator.estimateMinimumBound();
+    var firstPosition = this._manifestBoundsCalculator.getEstimatedMinimumSegmentTime();
     if (firstPosition === undefined) {
       return undefined;
     }
@@ -34042,7 +34312,7 @@ var TemplateRepresentationIndex = /*#__PURE__*/function () {
    * @returns {number|null|undefined}
    */;
   _proto._getLastSegmentStart = function _getLastSegmentStart() {
-    var _a;
+    var _a, _b;
     var _this$_index2 = this._index,
       duration = _this$_index2.duration,
       timescale = _this$_index2.timescale,
@@ -34050,34 +34320,34 @@ var TemplateRepresentationIndex = /*#__PURE__*/function () {
       _this$_index2$startNu = _this$_index2.startNumber,
       startNumber = _this$_index2$startNu === void 0 ? 1 : _this$_index2$startNu;
     if (this._isDynamic) {
-      var lastPos = this._manifestBoundsCalculator.estimateMaximumBound();
-      if (lastPos === undefined) {
-        return undefined;
-      }
-      if (this._scaledRelativePeriodEnd !== undefined && this._scaledRelativePeriodEnd < (lastPos - this._periodStart) * this._index.timescale) {
+      var liveEdge = this._manifestBoundsCalculator.getEstimatedLiveEdge();
+      if (liveEdge !== undefined && this._scaledRelativePeriodEnd !== undefined && this._scaledRelativePeriodEnd < liveEdge - this._periodStart * this._index.timescale) {
         var numberOfSegments = Math.ceil(this._scaledRelativePeriodEnd / duration);
         if (endNumber !== undefined && endNumber - startNumber + 1 < numberOfSegments) {
           numberOfSegments = endNumber - startNumber + 1;
         }
         return (numberOfSegments - 1) * duration;
       }
+      var lastPosition = this._manifestBoundsCalculator.getEstimatedMaximumPosition((_a = this._availabilityTimeOffset) !== null && _a !== void 0 ? _a : 0);
+      if (lastPosition === undefined) {
+        return undefined;
+      }
       // /!\ The scaled last position augments continuously and might not
       // reflect exactly the real server-side value. As segments are
       // generated discretely.
-      var scaledLastPosition = (lastPos - this._periodStart) * timescale;
+      var scaledLastPosition = (lastPosition - this._periodStart) * timescale;
       // Maximum position is before this period.
       // No segment is yet available here
       if (scaledLastPosition < 0) {
         return null;
       }
-      var availabilityTimeOffset = (this._availabilityTimeOffset !== undefined ? this._availabilityTimeOffset : 0) * timescale;
-      var numberOfSegmentsAvailable = Math.floor((scaledLastPosition + availabilityTimeOffset) / duration);
+      var numberOfSegmentsAvailable = Math.floor(scaledLastPosition / duration);
       if (endNumber !== undefined && endNumber - startNumber + 1 < numberOfSegmentsAvailable) {
         numberOfSegmentsAvailable = endNumber - startNumber + 1;
       }
       return numberOfSegmentsAvailable <= 0 ? null : (numberOfSegmentsAvailable - 1) * duration;
     } else {
-      var maximumTime = (_a = this._scaledRelativePeriodEnd) !== null && _a !== void 0 ? _a : 0;
+      var maximumTime = (_b = this._scaledRelativePeriodEnd) !== null && _b !== void 0 ? _b : 0;
       var _numberOfSegments = Math.ceil(maximumTime / duration);
       if (endNumber !== undefined && endNumber - startNumber + 1 < _numberOfSegments) {
         _numberOfSegments = endNumber - startNumber + 1;
@@ -34149,7 +34419,6 @@ function parseRepresentationIndex(representation, context) {
     periodEnd = context.end,
     periodStart = context.start,
     receivedTime = context.receivedTime,
-    timeShiftBufferDepth = context.timeShiftBufferDepth,
     unsafelyBaseOnPreviousRepresentation = context.unsafelyBaseOnPreviousRepresentation,
     inbandEventStreams = context.inbandEventStreams,
     isLastPeriod = context.isLastPeriod;
@@ -34163,7 +34432,7 @@ function parseRepresentationIndex(representation, context) {
     });
   };
   var reprIndexCtxt = {
-    availabilityTimeComplete: true,
+    availabilityTimeComplete: undefined,
     availabilityTimeOffset: availabilityTimeOffset,
     unsafelyBaseOnPreviousRepresentation: unsafelyBaseOnPreviousRepresentation,
     isEMSGWhitelisted: isEMSGWhitelisted,
@@ -34174,8 +34443,7 @@ function parseRepresentationIndex(representation, context) {
     periodStart: periodStart,
     receivedTime: receivedTime,
     representationBitrate: representation.attributes.bitrate,
-    representationId: representation.attributes.id,
-    timeShiftBufferDepth: timeShiftBufferDepth
+    representationId: representation.attributes.id
   };
   var representationIndex;
   if (representation.children.segmentBase !== undefined) {
@@ -34191,8 +34459,9 @@ function parseRepresentationIndex(representation, context) {
       segmentTemplates.push(childSegmentTemplate);
     }
     var segmentTemplate = object_assign.apply(void 0, [{}].concat(segmentTemplates));
-    reprIndexCtxt.availabilityTimeComplete = (_a = segmentTemplate.availabilityTimeComplete) !== null && _a !== void 0 ? _a : context.availabilityTimeComplete;
-    reprIndexCtxt.availabilityTimeOffset = ((_b = segmentTemplate.availabilityTimeOffset) !== null && _b !== void 0 ? _b : 0) + context.availabilityTimeOffset;
+    if (segmentTemplate.availabilityTimeOffset !== undefined || context.availabilityTimeOffset !== undefined) {
+      reprIndexCtxt.availabilityTimeOffset = ((_a = segmentTemplate.availabilityTimeOffset) !== null && _a !== void 0 ? _a : 0) + ((_b = context.availabilityTimeOffset) !== null && _b !== void 0 ? _b : 0);
+    }
     representationIndex = timeline.isTimelineIndexArgument(segmentTemplate) ? new timeline(segmentTemplate, reprIndexCtxt) : new TemplateRepresentationIndex(segmentTemplate, reprIndexCtxt);
   } else {
     var adaptationChildren = context.adaptation.children;
@@ -34287,6 +34556,7 @@ function parse_representations_arrayLikeToArray(arr, len) { if (len == null || l
 
 
 
+
 /**
  * Combine inband event streams from representation and
  * adaptation data.
@@ -34357,12 +34627,12 @@ function getHDRInformation(_ref) {
  * @returns {Array.<Object>}
  */
 function parseRepresentations(representationsIR, adaptation, context) {
-  var _a, _b, _c, _d;
+  var _a, _b, _c, _d, _e;
   var parsedRepresentations = [];
   var _loop = function _loop() {
     var representation = _step.value;
     // Compute Representation ID
-    var representationID = representation.attributes.id != null ? representation.attributes.id : String(representation.attributes.bitrate) + (representation.attributes.height != null ? "-" + representation.attributes.height : "") + (representation.attributes.width != null ? "-" + representation.attributes.width : "") + (representation.attributes.mimeType != null ? "-" + representation.attributes.mimeType : "") + (representation.attributes.codecs != null ? "-" + representation.attributes.codecs : "");
+    var representationID = representation.attributes.id !== undefined ? representation.attributes.id : String(representation.attributes.bitrate) + (representation.attributes.height !== undefined ? "-" + representation.attributes.height : "") + (representation.attributes.width !== undefined ? "-" + representation.attributes.width : "") + (representation.attributes.mimeType !== undefined ? "-" + representation.attributes.mimeType : "") + (representation.attributes.codecs !== undefined ? "-" + representation.attributes.codecs : "");
     // Avoid duplicate IDs
     while (parsedRepresentations.some(function (r) {
       return r.id === representationID;
@@ -34373,7 +34643,10 @@ function parseRepresentations(representationsIR, adaptation, context) {
     var unsafelyBaseOnPreviousRepresentation = (_b = (_a = context.unsafelyBaseOnPreviousAdaptation) === null || _a === void 0 ? void 0 : _a.getRepresentation(representationID)) !== null && _b !== void 0 ? _b : null;
     var inbandEventStreams = combineInbandEventStreams(representation, adaptation);
     var availabilityTimeComplete = (_c = representation.attributes.availabilityTimeComplete) !== null && _c !== void 0 ? _c : context.availabilityTimeComplete;
-    var availabilityTimeOffset = ((_d = representation.attributes.availabilityTimeOffset) !== null && _d !== void 0 ? _d : 0) + context.availabilityTimeOffset;
+    var availabilityTimeOffset;
+    if (representation.attributes.availabilityTimeOffset !== undefined || context.availabilityTimeOffset !== undefined) {
+      availabilityTimeOffset = ((_d = representation.attributes.availabilityTimeOffset) !== null && _d !== void 0 ? _d : 0) + ((_e = context.availabilityTimeOffset) !== null && _e !== void 0 ? _e : 0);
+    }
     var reprIndexCtxt = object_assign({}, context, {
       availabilityTimeOffset: availabilityTimeOffset,
       availabilityTimeComplete: availabilityTimeComplete,
@@ -34384,7 +34657,7 @@ function parseRepresentations(representationsIR, adaptation, context) {
     var representationIndex = parseRepresentationIndex(representation, reprIndexCtxt);
     // Find bitrate
     var representationBitrate;
-    if (representation.attributes.bitrate == null) {
+    if (representation.attributes.bitrate === undefined) {
       src_log.warn("DASH: No usable bitrate found in the Representation.");
       representationBitrate = 0;
     } else {
@@ -34419,33 +34692,42 @@ function parseRepresentations(representationsIR, adaptation, context) {
     }
     // Add optional attributes
     var codecs;
-    if (representation.attributes.codecs != null) {
+    if (representation.attributes.codecs !== undefined) {
       codecs = representation.attributes.codecs;
-    } else if (adaptation.attributes.codecs != null) {
+    } else if (adaptation.attributes.codecs !== undefined) {
       codecs = adaptation.attributes.codecs;
     }
-    if (codecs != null) {
+    if (codecs !== undefined) {
       codecs = codecs === "mp4a.40.02" ? "mp4a.40.2" : codecs;
       parsedRepresentation.codecs = codecs;
     }
-    if (representation.attributes.frameRate != null) {
+    var supplementalCodecs;
+    if (representation.attributes.supplementalCodecs !== undefined) {
+      supplementalCodecs = representation.attributes.supplementalCodecs;
+    } else if (adaptation.attributes.supplementalCodecs !== undefined) {
+      supplementalCodecs = adaptation.attributes.supplementalCodecs;
+    }
+    if (supplementalCodecs !== undefined) {
+      parsedRepresentation.supplementalCodecs = convertSupplementalCodecsToRFC6381(supplementalCodecs);
+    }
+    if (representation.attributes.frameRate !== undefined) {
       parsedRepresentation.frameRate = representation.attributes.frameRate;
-    } else if (adaptation.attributes.frameRate != null) {
+    } else if (adaptation.attributes.frameRate !== undefined) {
       parsedRepresentation.frameRate = adaptation.attributes.frameRate;
     }
-    if (representation.attributes.height != null) {
+    if (representation.attributes.height !== undefined) {
       parsedRepresentation.height = representation.attributes.height;
-    } else if (adaptation.attributes.height != null) {
+    } else if (adaptation.attributes.height !== undefined) {
       parsedRepresentation.height = adaptation.attributes.height;
     }
-    if (representation.attributes.mimeType != null) {
+    if (representation.attributes.mimeType !== undefined) {
       parsedRepresentation.mimeType = representation.attributes.mimeType;
-    } else if (adaptation.attributes.mimeType != null) {
+    } else if (adaptation.attributes.mimeType !== undefined) {
       parsedRepresentation.mimeType = adaptation.attributes.mimeType;
     }
-    if (representation.attributes.width != null) {
+    if (representation.attributes.width !== undefined) {
       parsedRepresentation.width = representation.attributes.width;
-    } else if (adaptation.attributes.width != null) {
+    } else if (adaptation.attributes.width !== undefined) {
       parsedRepresentation.width = adaptation.attributes.width;
     }
     var contentProtectionsIr = adaptation.children.contentProtections !== undefined ? adaptation.children.contentProtections : [];
@@ -34682,7 +34964,7 @@ function getAdaptationSetSwitchingIDs(adaptation) {
  * @returns {Array.<Object>}
  */
 function parseAdaptationSets(adaptationsIR, context) {
-  var _a, _b, _c, _d, _e, _f;
+  var _a, _b, _c, _d, _e, _f, _g;
   var parsedAdaptations = {
     video: [],
     audio: [],
@@ -34704,14 +34986,17 @@ function parseAdaptationSets(adaptationsIR, context) {
     });
     var representationsIR = adaptation.children.representations;
     var availabilityTimeComplete = (_a = adaptation.attributes.availabilityTimeComplete) !== null && _a !== void 0 ? _a : context.availabilityTimeComplete;
-    var availabilityTimeOffset = ((_b = adaptation.attributes.availabilityTimeOffset) !== null && _b !== void 0 ? _b : 0) + context.availabilityTimeOffset;
+    var availabilityTimeOffset = void 0;
+    if (adaptation.attributes.availabilityTimeOffset !== undefined || context.availabilityTimeOffset !== undefined) {
+      availabilityTimeOffset = ((_b = adaptation.attributes.availabilityTimeOffset) !== null && _b !== void 0 ? _b : 0) + ((_c = context.availabilityTimeOffset) !== null && _c !== void 0 ? _c : 0);
+    }
     var adaptationMimeType = adaptation.attributes.mimeType;
     var adaptationCodecs = adaptation.attributes.codecs;
     var type = inferAdaptationType(representationsIR, isNonEmptyString(adaptationMimeType) ? adaptationMimeType : null, isNonEmptyString(adaptationCodecs) ? adaptationCodecs : null, adaptationChildren.roles != null ? adaptationChildren.roles : null);
     if (type === undefined) {
       continue;
     }
-    var priority = (_c = adaptation.attributes.selectionPriority) !== null && _c !== void 0 ? _c : 1;
+    var priority = (_d = adaptation.attributes.selectionPriority) !== null && _d !== void 0 ? _d : 1;
     var originalID = adaptation.attributes.id;
     var adaptationSetSwitchingIDs = getAdaptationSetSwitchingIDs(adaptation);
     var parentSegmentTemplates = [];
@@ -34733,13 +35018,12 @@ function parseAdaptationSets(adaptationsIR, context) {
       parentSegmentTemplates: parentSegmentTemplates,
       receivedTime: context.receivedTime,
       start: context.start,
-      timeShiftBufferDepth: context.timeShiftBufferDepth,
       unsafelyBaseOnPreviousAdaptation: null
     };
     var trickModeProperty = Array.isArray(essentialProperties) ? arrayFind(essentialProperties, function (scheme) {
       return scheme.schemeIdUri === "http://dashif.org/guidelines/trickmode";
     }) : undefined;
-    var trickModeAttachedAdaptationIds = (_d = trickModeProperty === null || trickModeProperty === void 0 ? void 0 : trickModeProperty.value) === null || _d === void 0 ? void 0 : _d.split(" ");
+    var trickModeAttachedAdaptationIds = (_e = trickModeProperty === null || trickModeProperty === void 0 ? void 0 : trickModeProperty.value) === null || _e === void 0 ? void 0 : _e.split(" ");
     var isTrickModeTrack = trickModeAttachedAdaptationIds !== undefined;
     var accessibilities = adaptationChildren.accessibilities;
     var isDub = void 0;
@@ -34786,7 +35070,7 @@ function parseAdaptationSets(adaptationsIR, context) {
     }
     var newID = adaptationID;
     parsedAdaptationsIDs.push(adaptationID);
-    reprCtxt.unsafelyBaseOnPreviousAdaptation = (_f = (_e = context.unsafelyBaseOnPreviousPeriod) === null || _e === void 0 ? void 0 : _e.getAdaptation(adaptationID)) !== null && _f !== void 0 ? _f : null;
+    reprCtxt.unsafelyBaseOnPreviousAdaptation = (_g = (_f = context.unsafelyBaseOnPreviousPeriod) === null || _f === void 0 ? void 0 : _f.getAdaptation(adaptationID)) !== null && _g !== void 0 ? _g : null;
     var representations = parseRepresentations(representationsIR, adaptation, reprCtxt);
     var parsedAdaptationSet = {
       id: adaptationID,
@@ -34920,8 +35204,8 @@ function parse_periods_arrayLikeToArray(arr, len) { if (len == null || len > arr
 
 
 
-// eslint-disable-next-line max-len
 
+// eslint-disable-next-line max-len
 
 
 
@@ -34934,19 +35218,15 @@ var generatePeriodID = idGenerator();
  * @returns {Array.<Object>}
  */
 function parsePeriods(periodsIR, context) {
-  var _a, _b, _c, _d, _e, _f;
+  var _a, _b, _c, _d;
   var parsedPeriods = [];
   var periodsTimeInformation = getPeriodsTimeInformation(periodsIR, context);
   if (periodsTimeInformation.length !== periodsIR.length) {
     throw new Error("MPD parsing error: the time information are incoherent.");
   }
   var isDynamic = context.isDynamic,
-    timeShiftBufferDepth = context.timeShiftBufferDepth;
-  var manifestBoundsCalculator = new ManifestBoundsCalculator({
-    isDynamic: isDynamic,
-    timeShiftBufferDepth: timeShiftBufferDepth
-  });
-  if (!isDynamic && context.duration != null) {
+    manifestBoundsCalculator = context.manifestBoundsCalculator;
+  if (!isDynamic && !is_null_or_undefined_isNullOrUndefined(context.duration)) {
     manifestBoundsCalculator.setLastPosition(context.duration);
   }
   // We parse it in reverse because we might need to deduce the buffer depth from
@@ -34961,7 +35241,7 @@ function parsePeriods(periodsIR, context) {
       periodDuration = _periodsTimeInformati.periodDuration,
       periodEnd = _periodsTimeInformati.periodEnd;
     var periodID;
-    if (periodIR.attributes.id == null) {
+    if (is_null_or_undefined_isNullOrUndefined(periodIR.attributes.id)) {
       src_log.warn("DASH: No usable id found in the Period. Generating one.");
       periodID = "gen-dash-period-" + generatePeriodID();
     } else {
@@ -34975,8 +35255,8 @@ function parsePeriods(periodsIR, context) {
     }
     var receivedTime = xlinkInfos !== undefined ? xlinkInfos.receivedTime : context.receivedTime;
     var unsafelyBaseOnPreviousPeriod = (_b = (_a = context.unsafelyBaseOnPreviousManifest) === null || _a === void 0 ? void 0 : _a.getPeriod(periodID)) !== null && _b !== void 0 ? _b : null;
-    var availabilityTimeComplete = (_c = periodIR.attributes.availabilityTimeComplete) !== null && _c !== void 0 ? _c : true;
-    var availabilityTimeOffset = (_d = periodIR.attributes.availabilityTimeOffset) !== null && _d !== void 0 ? _d : 0;
+    var availabilityTimeComplete = periodIR.attributes.availabilityTimeComplete;
+    var availabilityTimeOffset = periodIR.attributes.availabilityTimeOffset;
     var manifestProfiles = context.manifestProfiles;
     var segmentTemplate = periodIR.children.segmentTemplate;
     var adapCtxt = {
@@ -34991,11 +35271,10 @@ function parsePeriods(periodsIR, context) {
       receivedTime: receivedTime,
       segmentTemplate: segmentTemplate,
       start: periodStart,
-      timeShiftBufferDepth: timeShiftBufferDepth,
       unsafelyBaseOnPreviousPeriod: unsafelyBaseOnPreviousPeriod
     };
     var adaptations = parseAdaptationSets(periodIR.children.adaptations, adapCtxt);
-    var namespaces = ((_e = context.xmlNamespaces) !== null && _e !== void 0 ? _e : []).concat((_f = periodIR.attributes.namespaces) !== null && _f !== void 0 ? _f : []);
+    var namespaces = ((_c = context.xmlNamespaces) !== null && _c !== void 0 ? _c : []).concat((_d = periodIR.attributes.namespaces) !== null && _d !== void 0 ? _d : []);
     var streamEvents = generateStreamEvents(periodIR.children.eventStreams, periodStart, namespaces);
     var parsedPeriod = {
       id: periodID,
@@ -35070,7 +35349,7 @@ function parsePeriods(periodsIR, context) {
  * @returns {Array.<number|undefined>}
  */
 function guessLastPositionFromClock(context, minimumTime) {
-  if (context.clockOffset != null) {
+  if (!is_null_or_undefined_isNullOrUndefined(context.clockOffset)) {
     var lastPosition = context.clockOffset / 1000 - context.availabilityStartTime;
     var positionTime = getMonotonicTimeStamp() / 1000;
     var timeInSec = positionTime + lastPosition;
@@ -35102,7 +35381,7 @@ function getMaximumLastPosition(adaptationsPerType) {
   var maxEncounteredPosition = null;
   var allIndexAreEmpty = true;
   var adaptationsVal = object_values(adaptationsPerType).filter(function (ada) {
-    return ada != null;
+    return !is_null_or_undefined_isNullOrUndefined(ada);
   });
   var allAdaptations = flatMap(adaptationsVal, function (adaptationsForType) {
     return adaptationsForType;
@@ -35116,12 +35395,12 @@ function getMaximumLastPosition(adaptationsPerType) {
       if (position !== null) {
         allIndexAreEmpty = false;
         if (typeof position === "number") {
-          maxEncounteredPosition = maxEncounteredPosition == null ? position : Math.max(maxEncounteredPosition, position);
+          maxEncounteredPosition = is_null_or_undefined_isNullOrUndefined(maxEncounteredPosition) ? position : Math.max(maxEncounteredPosition, position);
         }
       }
     }
   }
-  if (maxEncounteredPosition != null) {
+  if (!is_null_or_undefined_isNullOrUndefined(maxEncounteredPosition)) {
     return maxEncounteredPosition;
   } else if (allIndexAreEmpty) {
     return null;
@@ -35219,6 +35498,7 @@ function parse_mpd_arrayLikeToArray(arr, len) { if (len == null || len > arr.len
 
 
 
+
 /**
  * Checks if xlinks needs to be loaded before actually parsing the manifest.
  * @param {Object} mpdIR
@@ -35341,12 +35621,20 @@ function parseCompleteIntermediateRepresentation(mpdIR, args, warnings, xlinkInf
   var timeShiftBufferDepth = rootAttributes.timeShiftBufferDepth;
   var clockOffset = args.externalClockOffset,
     unsafelyBaseOnPreviousManifest = args.unsafelyBaseOnPreviousManifest;
+  var externalClockOffset = args.externalClockOffset;
+  var manifestBoundsCalculator = new ManifestBoundsCalculator({
+    availabilityStartTime: availabilityStartTime,
+    isDynamic: isDynamic,
+    timeShiftBufferDepth: timeShiftBufferDepth,
+    serverTimestampOffset: externalClockOffset
+  });
   var manifestInfos = {
     availabilityStartTime: availabilityStartTime,
     baseURLs: mpdBaseUrls,
     clockOffset: clockOffset,
     duration: rootAttributes.duration,
     isDynamic: isDynamic,
+    manifestBoundsCalculator: manifestBoundsCalculator,
     manifestProfiles: mpdIR.attributes.profiles,
     receivedTime: args.manifestReceivedTime,
     timeShiftBufferDepth: timeShiftBufferDepth,
@@ -35388,29 +35676,32 @@ function parseCompleteIntermediateRepresentation(mpdIR, args, warnings, xlinkInf
       time: now
     };
   } else {
-    minimumTime = minimumSafePosition;
-    timeshiftDepth = timeShiftBufferDepth !== null && timeShiftBufferDepth !== void 0 ? timeShiftBufferDepth : null;
+    // Determine the maximum seekable position
     var _finalMaximumSafePosition;
-    var livePosition;
-    if (maximumUnsafePosition !== undefined) {
-      livePosition = maximumUnsafePosition;
-    }
     if (maximumSafePosition !== undefined) {
       _finalMaximumSafePosition = maximumSafePosition;
     } else {
-      var ast = availabilityStartTime !== null && availabilityStartTime !== void 0 ? availabilityStartTime : 0;
-      var externalClockOffset = args.externalClockOffset;
       if (externalClockOffset === undefined) {
         src_log.warn("DASH Parser: use system clock to define maximum position");
-        _finalMaximumSafePosition = Date.now() / 1000 - ast;
+        _finalMaximumSafePosition = Date.now() / 1000 - availabilityStartTime;
       } else {
         var serverTime = getMonotonicTimeStamp() + externalClockOffset;
-        _finalMaximumSafePosition = serverTime / 1000 - ast;
+        _finalMaximumSafePosition = serverTime / 1000 - availabilityStartTime;
       }
     }
+    // Determine live edge (what position corresponds to live content, can be
+    // inferior or superior to the maximum anounced position in some specific
+    // scenarios). However, the `timeShiftBufferDepth` should be based on it.
+    var livePosition = manifestBoundsCalculator.getEstimatedLiveEdge();
     if (livePosition === undefined) {
-      livePosition = _finalMaximumSafePosition;
+      if (maximumUnsafePosition !== undefined) {
+        livePosition = maximumUnsafePosition;
+      } else {
+        livePosition = _finalMaximumSafePosition;
+      }
+      // manifestBoundsCalculator.forceLiveEdge(livePosition);
     }
+
     maximumTimeData = {
       isLinear: true,
       maximumSafePosition: _finalMaximumSafePosition,
@@ -35419,8 +35710,10 @@ function parseCompleteIntermediateRepresentation(mpdIR, args, warnings, xlinkInf
     };
     // if the minimum calculated time is even below the buffer depth, perhaps we
     // can go even lower in terms of depth
-    if (timeshiftDepth !== null && minimumTime !== undefined && _finalMaximumSafePosition - minimumTime > timeshiftDepth) {
-      timeshiftDepth = _finalMaximumSafePosition - minimumTime;
+    minimumTime = minimumSafePosition;
+    timeshiftDepth = timeShiftBufferDepth !== null && timeShiftBufferDepth !== void 0 ? timeShiftBufferDepth : null;
+    if (timeshiftDepth !== null && minimumTime !== undefined && livePosition - minimumTime > timeshiftDepth) {
+      timeshiftDepth = livePosition - minimumTime;
     }
   }
   // `isLastPeriodKnown` should be `true` in two cases for DASH contents:
@@ -36490,6 +36783,9 @@ function parseRepresentationAttributes(representationElement) {
           dashName: "qualityRanking"
         });
         break;
+      case "scte214:supplementalCodecs":
+        attributes.supplementalCodecs = attr.value;
+        break;
       case "segmentProfiles":
         attributes.segmentProfiles = attr.value;
         break;
@@ -36816,6 +37112,9 @@ function parseAdaptationSetAttributes(root) {
       case "codecs":
         parsedAdaptation.codecs = attribute.value;
         break;
+      case "scte214:supplementalCodecs":
+        parsedAdaptation.supplementalCodecs = attribute.value;
+        break;
       case "codingDependency":
         parseValue(attribute.value, {
           asKey: "codingDependency",
@@ -37567,15 +37866,18 @@ function generateManifestParser(options) {
       var externalResources = value.urls.map(function (resourceUrl) {
         return scheduleRequest(function () {
           var defaultTimeout = config.getCurrent().DEFAULT_REQUEST_TIMEOUT;
+          var defaultConnectionTimeout = config.getCurrent().DEFAULT_CONNECTION_TIMEOUT;
           return value.format === "string" ? utils_request({
             url: resourceUrl,
             responseType: "text",
             timeout: defaultTimeout,
+            connectionTimeout: defaultConnectionTimeout,
             cancelSignal: cancelSignal
           }) : utils_request({
             url: resourceUrl,
             responseType: "arraybuffer",
             timeout: defaultTimeout,
+            connectionTimeout: defaultConnectionTimeout,
             cancelSignal: cancelSignal
           });
         }).then(function (res) {
@@ -37769,7 +38071,8 @@ function fetchRequest(options) {
   }
   src_log.debug("Fetch: Called with URL", options.url);
   var cancellation = null;
-  var timeouted = false;
+  var isTimedOut = false;
+  var isConnectionTimedOut = false;
   var sendingTime = getMonotonicTimeStamp();
   var abortController = !is_null_or_undefined_isNullOrUndefined(_AbortController) ? new _AbortController() : null;
   /**
@@ -37783,13 +38086,26 @@ function fetchRequest(options) {
     }
     abortController.abort();
   }
-  var timeout;
+  var timeoutId;
   if (options.timeout !== undefined) {
-    timeout = setTimeout(function () {
-      timeouted = true;
+    timeoutId = setTimeout(function () {
+      isTimedOut = true;
+      if (connectionTimeoutId !== undefined) {
+        clearTimeout(connectionTimeoutId);
+      }
       abortFetch();
     }, options.timeout);
   }
+  var connectionTimeoutId;
+  if (options.connectionTimeout !== undefined) {
+    connectionTimeoutId = setTimeout(function () {
+      isConnectionTimedOut = true;
+      if (timeoutId !== undefined) {
+        clearTimeout(timeoutId);
+      }
+      abortFetch();
+    }, options.connectionTimeout);
+  }
   var deregisterCancelLstnr = options.cancelSignal.register(function abortRequest(err) {
     cancellation = err;
     abortFetch();
@@ -37802,8 +38118,8 @@ function fetchRequest(options) {
   }
   fetchOpts.signal = !is_null_or_undefined_isNullOrUndefined(abortController) ? abortController.signal : null;
   return fetch(options.url, fetchOpts).then(function (response) {
-    if (!is_null_or_undefined_isNullOrUndefined(timeout)) {
-      clearTimeout(timeout);
+    if (connectionTimeoutId !== undefined) {
+      clearTimeout(connectionTimeoutId);
     }
     if (response.status >= 300) {
       src_log.warn("Fetch: Request HTTP Error", response.status, response.url);
@@ -37850,9 +38166,12 @@ function fetchRequest(options) {
               return _context.abrupt("return", readBufferAndSendEvents());
             case 11:
               if (!data.done) {
-                _context.next = 16;
+                _context.next = 17;
                 break;
               }
+              if (timeoutId !== undefined) {
+                clearTimeout(timeoutId);
+              }
               deregisterCancelLstnr();
               receivedTime = getMonotonicTimeStamp();
               requestDuration = receivedTime - sendingTime;
@@ -37864,9 +38183,9 @@ function fetchRequest(options) {
                 status: response.status,
                 url: response.url
               });
-            case 16:
-              return _context.abrupt("return", readBufferAndSendEvents());
             case 17:
+              return _context.abrupt("return", readBufferAndSendEvents());
+            case 18:
             case "end":
               return _context.stop();
           }
@@ -37879,8 +38198,11 @@ function fetchRequest(options) {
       throw cancellation;
     }
     deregisterCancelLstnr();
-    if (timeouted) {
-      src_log.warn("Fetch: Request timeouted.");
+    if (isTimedOut) {
+      src_log.warn("Fetch: Request timed out.");
+      throw new RequestError(options.url, 0, NetworkErrorTypes.TIMEOUT);
+    } else if (isConnectionTimedOut) {
+      src_log.warn("Fetch: Request connection timed out.");
       throw new RequestError(options.url, 0, NetworkErrorTypes.TIMEOUT);
     } else if (err instanceof RequestError) {
       throw err;
@@ -38073,6 +38395,7 @@ function initSegmentLoader(url, segment, options, cancelSignal, callbacks) {
       url: url,
       responseType: "arraybuffer",
       timeout: options.timeout,
+      connectionTimeout: options.connectionTimeout,
       cancelSignal: cancelSignal,
       onProgress: callbacks.onProgress
     }).then(function (data) {
@@ -38090,6 +38413,7 @@ function initSegmentLoader(url, segment, options, cancelSignal, callbacks) {
       },
       responseType: "arraybuffer",
       timeout: options.timeout,
+      connectionTimeout: options.connectionTimeout,
       cancelSignal: cancelSignal,
       onProgress: callbacks.onProgress
     }).then(function (data) {
@@ -38108,6 +38432,7 @@ function initSegmentLoader(url, segment, options, cancelSignal, callbacks) {
       },
       responseType: "arraybuffer",
       timeout: options.timeout,
+      connectionTimeout: options.connectionTimeout,
       cancelSignal: cancelSignal,
       onProgress: callbacks.onProgress
     }).then(function (data) {
@@ -38124,6 +38449,7 @@ function initSegmentLoader(url, segment, options, cancelSignal, callbacks) {
     },
     responseType: "arraybuffer",
     timeout: options.timeout,
+    connectionTimeout: options.connectionTimeout,
     cancelSignal: cancelSignal,
     onProgress: callbacks.onProgress
   });
@@ -38134,6 +38460,7 @@ function initSegmentLoader(url, segment, options, cancelSignal, callbacks) {
     },
     responseType: "arraybuffer",
     timeout: options.timeout,
+    connectionTimeout: options.connectionTimeout,
     cancelSignal: cancelSignal,
     onProgress: callbacks.onProgress
   });
@@ -38347,6 +38674,7 @@ function segment_loader_regularSegmentLoader(url, context, lowLatencyMode, optio
       Range: byteRange(segment.range)
     } : undefined,
     timeout: options.timeout,
+    connectionTimeout: options.connectionTimeout,
     cancelSignal: cancelSignal,
     onProgress: callbacks.onProgress
   }).then(function (data) {
@@ -39237,6 +39565,7 @@ function generateTextTrackLoader(_ref) {
           Range: byteRange(range)
         } : null,
         timeout: options.timeout,
+        connectionTimeout: options.connectionTimeout,
         onProgress: callbacks.onProgress,
         cancelSignal: cancelSignal
       }).then(function (data) {
@@ -39253,6 +39582,7 @@ function generateTextTrackLoader(_ref) {
         Range: byteRange(range)
       } : null,
       timeout: options.timeout,
+      connectionTimeout: options.connectionTimeout,
       onProgress: callbacks.onProgress,
       cancelSignal: cancelSignal
     }).then(function (data) {
@@ -40450,6 +40780,7 @@ function disableVideoTracks(videoTracks) {
 
 
 
+
 /**
  * `ContentIntializer` which will load contents by putting their URL in the
  * `src` attribute of the given HTMLMediaElement.
@@ -40635,10 +40966,10 @@ var DirectFileContentInitializer = /*#__PURE__*/function (_ContentInitializer) {
  */
 
 function getDirectFileInitialTime(mediaElement, startAt) {
-  if (startAt == null) {
+  if (is_null_or_undefined_isNullOrUndefined(startAt)) {
     return 0;
   }
-  if (startAt.position != null) {
+  if (!is_null_or_undefined_isNullOrUndefined(startAt.position)) {
     return startAt.position;
   } else if (startAt.wallClockTime != null) {
     return startAt.wallClockTime;
@@ -40646,13 +40977,24 @@ function getDirectFileInitialTime(mediaElement, startAt) {
     return startAt.fromFirstPosition;
   }
   var duration = mediaElement.duration;
-  if (duration == null || !isFinite(duration)) {
-    src_log.warn("startAt.fromLastPosition set but no known duration, " + "beginning at 0.");
-    return 0;
-  }
   if (typeof startAt.fromLastPosition === "number") {
+    if (is_null_or_undefined_isNullOrUndefined(duration) || !isFinite(duration)) {
+      src_log.warn("startAt.fromLastPosition set but no known duration, " + "beginning at 0.");
+      return 0;
+    }
     return Math.max(0, duration + startAt.fromLastPosition);
+  } else if (typeof startAt.fromLivePosition === "number") {
+    var livePosition = mediaElement.seekable.length > 0 ? mediaElement.seekable.end(0) : duration;
+    if (is_null_or_undefined_isNullOrUndefined(livePosition)) {
+      src_log.warn("startAt.fromLivePosition set but no known live position, " + "beginning at 0.");
+      return 0;
+    }
+    return Math.max(0, livePosition + startAt.fromLivePosition);
   } else if (startAt.percentage != null) {
+    if (is_null_or_undefined_isNullOrUndefined(duration) || !isFinite(duration)) {
+      src_log.warn("startAt.percentage set but no known duration, " + "beginning at 0.");
+      return 0;
+    }
     var percentage = startAt.percentage;
     if (percentage >= 100) {
       return duration;
@@ -49548,6 +49890,21 @@ function parseTextTrackToElements(type, data, timestampOffset, language) {
  * Setting a value too high might lead to two segments targeting different times
  * to be wrongly believed to target the same time. In worst case scenarios, this
  * could lead to wanted text tracks being removed.
+ *
+ * When comparing 2 segments s1 and s2, you may want to take into account the duration
+ * of the segments:
+ *   - if s1 is [0, 2] and s2 is [0, 2.1] s1 and s2 can be considered as nearly equal as
+ *     there is a relative difference of: (2.1-2) / 2 = 5%;
+ *     Formula: (end_s1 - end_s2) / duration_s2 = relative_difference
+ *   - if s1 is [0, 0.04] and s2 is [0.04, 0.08] s1 and s2 may not considered as nearly
+ *     equal as there is a relative difference of: (0.04-0.08) / 0.04 = 100%
+ *
+ * To compare relatively to the duration of a segment you can provide and additional
+ * parameter "delta" that remplace MAX_DELTA_BUFFER_TIME.
+ * If parameter "delta" is higher than MAX_DELTA_BUFFER_TIME, MAX_DELTA_BUFFER_TIME
+ * is used instead of delta. This ensure that segments are nearly equal when comparing
+ * relatively AND absolutely.
+ *
  * @type Number
  */
 var MAX_DELTA_BUFFER_TIME = 0.2;
@@ -49555,10 +49912,14 @@ var MAX_DELTA_BUFFER_TIME = 0.2;
  * @see MAX_DELTA_BUFFER_TIME
  * @param {Number} a
  * @param {Number} b
+ * @param {Number} delta
  * @returns {Boolean}
  */
-function areNearlyEqual(a, b) {
-  return Math.abs(a - b) <= MAX_DELTA_BUFFER_TIME;
+function areNearlyEqual(a, b, delta) {
+  if (delta === void 0) {
+    delta = MAX_DELTA_BUFFER_TIME;
+  }
+  return Math.abs(a - b) <= Math.min(delta, MAX_DELTA_BUFFER_TIME);
 }
 /**
  * Get all cues which have data before the given time.
@@ -49631,6 +49992,22 @@ function removeCuesInfosBetween(cuesInfos, start, end) {
  */
 
 
+/**
+ * first or last IHTMLCue in a group can have a slighlty different start
+ * or end time than the start or end time of the ICuesGroup due to parsing
+ * approximation.
+ * DELTA_CUES_GROUP defines the tolerance level when comparing the start/end
+ * of a IHTMLCue to the start/end of a ICuesGroup.
+ * Having this value too high may lead to have unwanted subtitle displayed
+ * Having this value too low may lead to have subtitles not displayed
+ */
+var DELTA_CUES_GROUP = 1e-3;
+/**
+ * segment_duration / RELATIVE_DELTA_RATIO = relative_delta
+ *
+ * relative_delta is the tolerance to determine if two segements are the same
+ */
+var RELATIVE_DELTA_RATIO = 5;
 /**
  * Manage the buffer of the HTMLTextSegmentBuffer.
  * Allows to add, remove and recuperate cues at given times.
@@ -49674,6 +50051,17 @@ var TextTrackCuesStore = /*#__PURE__*/function () {
             ret.push(cues[j].element);
           }
         }
+        // first or last IHTMLCue in a group can have a slighlty different start
+        // or end time than the start or end time of the ICuesGroup due to parsing
+        // approximation.
+        // Add a tolerance of 1ms to fix this issue
+        if (ret.length === 0 && cues.length > 0) {
+          for (var _j = 0; _j < cues.length; _j++) {
+            if (areNearlyEqual(time, cues[_j].start, DELTA_CUES_GROUP) || areNearlyEqual(time, cues[_j].end, DELTA_CUES_GROUP)) {
+              ret.push(cues[_j].element);
+            }
+          }
+        }
         return ret;
       }
     }
@@ -49760,6 +50148,11 @@ var TextTrackCuesStore = /*#__PURE__*/function () {
       end: end,
       cues: cues
     };
+    // it's preferable to have a delta depending on the duration of the segment
+    // if the delta is one fifth of the length of the segment:
+    // a segment of [0, 2] is the "same" segment as [0, 2.1]
+    // but [0, 0.04] is not the "same" segement as [0,04, 0.08]
+    var relativeDelta = Math.abs(start - end) / RELATIVE_DELTA_RATIO;
     /**
      * Called when we found the index of the next cue relative to the cue we
      * want to insert (that is a cue starting after its start or at the same
@@ -49772,7 +50165,7 @@ var TextTrackCuesStore = /*#__PURE__*/function () {
       var nextCue = cuesBuffer[indexOfNextCue];
       if (nextCue === undefined ||
       // no cue
-      areNearlyEqual(cuesInfosToInsert.end, nextCue.end))
+      areNearlyEqual(cuesInfosToInsert.end, nextCue.end, relativeDelta))
         // samey end
         {
           //   ours:            |AAAAA|
@@ -49807,8 +50200,8 @@ var TextTrackCuesStore = /*#__PURE__*/function () {
     for (var cueIdx = 0; cueIdx < cuesBuffer.length; cueIdx++) {
       var cuesInfos = cuesBuffer[cueIdx];
       if (start < cuesInfos.end) {
-        if (areNearlyEqual(start, cuesInfos.start)) {
-          if (areNearlyEqual(end, cuesInfos.end)) {
+        if (areNearlyEqual(start, cuesInfos.start, relativeDelta)) {
+          if (areNearlyEqual(end, cuesInfos.end, relativeDelta)) {
             // exact same segment
             //   ours:            |AAAAA|
             //   the current one: |BBBBB|
@@ -49853,7 +50246,7 @@ var TextTrackCuesStore = /*#__PURE__*/function () {
             //   - add ours before the current one
             cuesBuffer.splice(cueIdx, 0, cuesInfosToInsert);
             return;
-          } else if (areNearlyEqual(end, cuesInfos.start)) {
+          } else if (areNearlyEqual(end, cuesInfos.start, relativeDelta)) {
             // our cue goes just before the current one:
             //   ours:            |AAAAAAA|
             //   the current one:         |BBBB|
@@ -49864,7 +50257,7 @@ var TextTrackCuesStore = /*#__PURE__*/function () {
             cuesInfos.start = end;
             cuesBuffer.splice(cueIdx, 0, cuesInfosToInsert);
             return;
-          } else if (areNearlyEqual(end, cuesInfos.end)) {
+          } else if (areNearlyEqual(end, cuesInfos.end, relativeDelta)) {
             //   ours:            |AAAAAAA|
             //   the current one:    |BBBB|
             //   Result:          |AAAAAAA|
@@ -49891,7 +50284,7 @@ var TextTrackCuesStore = /*#__PURE__*/function () {
           return;
         }
         // else -> start > cuesInfos.start
-        if (areNearlyEqual(cuesInfos.end, end)) {
+        if (areNearlyEqual(cuesInfos.end, end, relativeDelta)) {
           //   ours:              |AAAAAA|
           //   the current one: |BBBBBBBB|
           //   Result:          |BBAAAAAA|
@@ -49927,6 +50320,21 @@ var TextTrackCuesStore = /*#__PURE__*/function () {
         }
       }
     }
+    if (cuesBuffer.length) {
+      var lastCue = cuesBuffer[cuesBuffer.length - 1];
+      if (areNearlyEqual(lastCue.end, start, relativeDelta)) {
+        // Match the end of the previous cue to the start of the following one
+        // if they are close enough. If there is a small gap between two segments
+        // it can lead to having no subtitles for a short time, this is noticeable when
+        // two successive segments displays the same text, making it diseappear
+        // and reappear quickly, which gives the impression of blinking
+        //
+        //   ours:                   |AAAAA|
+        //   the current one: |BBBBB|...
+        //   Result:          |BBBBBBBAAAAA|
+        lastCue.end = start;
+      }
+    }
     // no cues group has the end after our current start.
     // These cues should be the last one
     cuesBuffer.push(cuesInfosToInsert);