rx-player 4.0.0-dev.2023111400 → 4.0.0-dev.2023121900

package/dist/rx-player.js

@@ -535,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
@@ -660,6 +665,22 @@ var DEFAULT_CONFIG = {
   },
   /* eslint-enable @typescript-eslint/consistent-type-assertions */
   /* eslint-disable @typescript-eslint/consistent-type-assertions */
+  /**
+   * Minimum possible buffer ahead for each type of buffer, to avoid Garbage
+   * Collecting too much data when it would have adverse effects.
+   * Equal to `0` if not defined here.
+   * @type {Object}
+   */
+  MINIMUM_MAX_BUFFER_AHEAD: {
+    // Text segments are both much lighter on resources and might
+    // actually be much larger than other types of segments in terms
+    // of duration. Let's make an exception here by authorizing a
+    // larger text buffer ahead, to avoid unnecesarily reloading the
+    // same text track.
+    text: 2 * 60
+  },
+  /* eslint-enable @typescript-eslint/consistent-type-assertions */
+  /* eslint-disable @typescript-eslint/consistent-type-assertions */
   /**
    * Maximum possible buffer behind for each type of buffer, to avoid too much
    * memory usage when playing for a long time.
@@ -725,22 +746,6 @@ var DEFAULT_CONFIG = {
    * @type {Number}
    */
   BUFFER_DISCONTINUITY_THRESHOLD: 0.2,
-  /**
-   * When encountering small discontinuities, the RxPlayer may want, in specific
-   * conditions, ignore those and let the browser seek over them iself (this
-   * allows for example to avoid conflicts when both the browser and the
-   * RxPlayer want to seek at a different position, sometimes leading to a
-   * seeking loop).
-   * In this case, we however still want to seek it ourselves if the browser
-   * doesn't take the opportunity soon enough.
-   *
-   * This value specifies a delay after which a discontinuity ignored by the
-   * RxPlayer is finally considered.
-   * We want to maintain high enough to be sure the browser will not seek yet
-   * small enough so this (arguably rare) situation won't lead to too much
-   * waiting time.
-   */
-  FORCE_DISCONTINUITY_SEEK_DELAY: 5000,
   /**
    * Ratio used to know if an already loaded segment should be re-buffered.
    * We re-load the given segment if the current one times that ratio is
@@ -5215,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
@@ -5260,6 +5264,36 @@ function parseLoadVideoOptions(options) {
   };
 }
 
+;// CONCATENATED MODULE: ./src/compat/is_seeking_approximate.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.
+ */
+
+/**
+ * On some devices (right now only seen on Tizen), seeking through the
+ * `currentTime` property can lead to the browser re-seeking once the
+ * segments have been loaded to improve seeking performances (for
+ * example, by seeking right to an intra video frame).
+ *
+ * This can lead to conflicts with the RxPlayer code.
+ *
+ * This boolean is only `true` on the devices where this behavior has been
+ * observed.
+ */
+var isSeekingApproximate = isTizen;
+/* harmony default export */ var is_seeking_approximate = (isSeekingApproximate);
 ;// CONCATENATED MODULE: ./src/utils/monotonic_timestamp.ts
 /**
  * Returns a monotonically-increasing timestamp in milliseconds that is
@@ -5297,6 +5331,7 @@ function getMonotonicTimeStamp() {
 
 
 
+
 /**
  * HTMLMediaElement Events for which playback observations are calculated and
  * emitted.
@@ -5328,12 +5363,26 @@ var PlaybackObserver = /*#__PURE__*/function () {
    * @param {Object} options
    */
   function PlaybackObserver(mediaElement, options) {
+    var _this = this;
     this._internalSeeksIncoming = [];
     this._mediaElement = mediaElement;
     this._withMediaSource = options.withMediaSource;
     this._lowLatencyMode = options.lowLatencyMode;
     this._canceller = new TaskCanceller();
     this._observationRef = this._createSharedReference();
+    this._expectedSeekingPosition = null;
+    this._pendingSeek = null;
+    var onLoadedMetadata = function onLoadedMetadata() {
+      if (_this._pendingSeek !== null) {
+        var positionToSeekTo = _this._pendingSeek;
+        _this._pendingSeek = null;
+        _this._actuallySetCurrentTime(positionToSeekTo);
+      }
+    };
+    mediaElement.addEventListener("loadedmetadata", onLoadedMetadata);
+    this._canceller.signal.register(function () {
+      mediaElement.removeEventListener("loadedmetadata", onLoadedMetadata);
+    });
   }
   /**
    * Stop the `PlaybackObserver` from emitting playback observations and free all
@@ -5384,9 +5433,13 @@ var PlaybackObserver = /*#__PURE__*/function () {
    * @param {number} time
    */;
   _proto.setCurrentTime = function setCurrentTime(time) {
-    this._internalSeeksIncoming.push(time);
-    src_log.info("API: Seeking internally", time);
-    this._mediaElement.currentTime = time;
+    if (this._mediaElement.readyState >= 1) {
+      this._actuallySetCurrentTime(time);
+    } else {
+      this._internalSeeksIncoming = [];
+      this._pendingSeek = time;
+      this._generateObservationForEvent("manual");
+    }
   }
   /**
    * Update the playback rate of the `HTMLMediaElement`.
@@ -5450,6 +5503,11 @@ var PlaybackObserver = /*#__PURE__*/function () {
    */;
   _proto.deriveReadOnlyObserver = function deriveReadOnlyObserver(transform) {
     return generateReadOnlyObserver(this, transform, this._canceller.signal);
+  };
+  _proto._actuallySetCurrentTime = function _actuallySetCurrentTime(time) {
+    src_log.info("API: Seeking internally", time);
+    this._internalSeeksIncoming.push(time);
+    this._mediaElement.currentTime = time;
   }
   /**
    * Creates the `IReadOnlySharedReference` that will generate playback
@@ -5457,66 +5515,28 @@ var PlaybackObserver = /*#__PURE__*/function () {
    * @returns {Object}
    */;
   _proto._createSharedReference = function _createSharedReference() {
-    var _this = this;
+    var _this2 = this;
     if (this._observationRef !== undefined) {
       return this._observationRef;
     }
-    var lastObservation;
     var _config$getCurrent = config.getCurrent(),
       SAMPLING_INTERVAL_MEDIASOURCE = _config$getCurrent.SAMPLING_INTERVAL_MEDIASOURCE,
       SAMPLING_INTERVAL_LOW_LATENCY = _config$getCurrent.SAMPLING_INTERVAL_LOW_LATENCY,
       SAMPLING_INTERVAL_NO_MEDIASOURCE = _config$getCurrent.SAMPLING_INTERVAL_NO_MEDIASOURCE;
-    var getCurrentObservation = function getCurrentObservation(event) {
-      var tmpEvt = event;
-      var startedInternalSeekTime;
-      if (tmpEvt === "seeking" && _this._internalSeeksIncoming.length > 0) {
-        tmpEvt = "internal-seeking";
-        startedInternalSeekTime = _this._internalSeeksIncoming.shift();
-      }
-      var _lastObservation = lastObservation !== null && lastObservation !== void 0 ? lastObservation : _this._generateInitialObservation();
-      var mediaTimings = getMediaInfos(_this._mediaElement, tmpEvt, _this._withMediaSource);
-      var pendingInternalSeek = null;
-      if (mediaTimings.seeking) {
-        if (typeof startedInternalSeekTime === "number") {
-          pendingInternalSeek = startedInternalSeekTime;
-        } else if (_lastObservation.pendingInternalSeek !== null && event !== "seeking") {
-          pendingInternalSeek = _lastObservation.pendingInternalSeek;
-        }
-      }
-      var rebufferingStatus = getRebufferingStatus(_lastObservation, mediaTimings, {
-        lowLatencyMode: _this._lowLatencyMode,
-        withMediaSource: _this._withMediaSource
-      });
-      var freezingStatus = getFreezingStatus(_lastObservation, mediaTimings);
-      var timings = object_assign({}, {
-        rebuffering: rebufferingStatus,
-        freezing: freezingStatus,
-        pendingInternalSeek: pendingInternalSeek
-      }, mediaTimings);
-      if (src_log.hasLevel("DEBUG")) {
-        src_log.debug("API: current media element state tick", "event", timings.event, "position", timings.position, "seeking", timings.seeking, "internalSeek", timings.pendingInternalSeek, "rebuffering", timings.rebuffering !== null, "freezing", timings.freezing !== null, "ended", timings.ended, "paused", timings.paused, "playbackRate", timings.playbackRate, "readyState", timings.readyState);
-      }
-      return timings;
-    };
-    var returnedSharedReference = new utils_reference(getCurrentObservation("init"), this._canceller.signal);
-    var generateObservationForEvent = function generateObservationForEvent(event) {
-      var newObservation = getCurrentObservation(event);
-      if (src_log.hasLevel("DEBUG")) {
-        src_log.debug("API: current playback timeline:\n" + prettyPrintBuffered(newObservation.buffered, newObservation.position), "\n" + event);
-      }
-      lastObservation = newObservation;
-      returnedSharedReference.setValue(newObservation);
-    };
+    var returnedSharedReference = new utils_reference(this._getCurrentObservation("init"), this._canceller.signal);
     var interval = this._lowLatencyMode ? SAMPLING_INTERVAL_LOW_LATENCY : this._withMediaSource ? SAMPLING_INTERVAL_MEDIASOURCE : SAMPLING_INTERVAL_NO_MEDIASOURCE;
+    var onInterval = function onInterval() {
+      _this2._generateObservationForEvent("timeupdate");
+    };
     var intervalId = setInterval(onInterval, interval);
     var removeEventListeners = SCANNED_MEDIA_ELEMENTS_EVENTS.map(function (eventName) {
-      _this._mediaElement.addEventListener(eventName, onMediaEvent);
-      function onMediaEvent() {
+      var onMediaEvent = function onMediaEvent() {
         restartInterval();
-        generateObservationForEvent(eventName);
-      }
+        _this2._generateObservationForEvent(eventName);
+      };
+      _this2._mediaElement.addEventListener(eventName, onMediaEvent);
       return function () {
-        _this._mediaElement.removeEventListener(eventName, onMediaEvent);
+        _this2._mediaElement.removeEventListener(eventName, onMediaEvent);
       };
     });
     this._canceller.signal.register(function () {
@@ -5527,23 +5547,160 @@ var PlaybackObserver = /*#__PURE__*/function () {
       returnedSharedReference.finish();
     });
     return returnedSharedReference;
-    function onInterval() {
-      generateObservationForEvent("timeupdate");
-    }
     function restartInterval() {
       clearInterval(intervalId);
       intervalId = setInterval(onInterval, interval);
     }
   };
-  _proto._generateInitialObservation = function _generateInitialObservation() {
-    return object_assign(getMediaInfos(this._mediaElement, "init", this._withMediaSource), {
-      rebuffering: null,
-      freezing: null,
-      pendingInternalSeek: null
+  _proto._getCurrentObservation = function _getCurrentObservation(event) {
+    var _a;
+    /** Actual event emitted through an observation. */
+    var tmpEvt = event;
+    // NOTE: `this._observationRef` may be `undefined` because we might here be
+    // called in the constructor when that property is not yet set.
+    var previousObservation = this._observationRef === undefined ? getInitialObservation(this._mediaElement, this._withMediaSource) : this._observationRef.getValue();
+    /**
+     * If `true`, there is a seek operation ongoing but it was done from the
+     * `PlaybackObserver`'s `setCurrentTime` method, not from external code.
+     */
+    var isInternalSeeking = false;
+    /** If set, the position for which we plan to seek to as soon as possible. */
+    var pendingPosition = this._pendingSeek;
+    /** Initially-polled playback observation, before adjustments. */
+    var mediaTimings = getMediaInfos(this._mediaElement, this._withMediaSource);
+    if (tmpEvt === "seeking") {
+      // We just began seeking.
+      // Let's find out if the seek is internal or external and handle approximate
+      // seeking
+      if (this._internalSeeksIncoming.length > 0) {
+        isInternalSeeking = true;
+        tmpEvt = "internal-seeking";
+        var startedInternalSeekTime = this._internalSeeksIncoming.shift();
+        this._expectedSeekingPosition = is_seeking_approximate ? Math.max(mediaTimings.position, startedInternalSeekTime !== null && startedInternalSeekTime !== void 0 ? startedInternalSeekTime : 0) : mediaTimings.position;
+      } else {
+        this._expectedSeekingPosition = mediaTimings.position;
+      }
+    } else if (mediaTimings.seeking) {
+      // we're still seeking, this time without a "seeking" event so it's an
+      // already handled one, keep track of the last wanted position we wanted
+      // to seek to, to work-around devices re-seeking silently.
+      this._expectedSeekingPosition = Math.max(mediaTimings.position, (_a = this._expectedSeekingPosition) !== null && _a !== void 0 ? _a : 0);
+    } else if (is_seeking_approximate && this._expectedSeekingPosition !== null && mediaTimings.position < this._expectedSeekingPosition) {
+      // We're on a target with aproximate seeking, we're not seeking anymore, but
+      // we're not yet at the expected seeking position.
+      // Signal to the rest of the application that the intented position is not
+      // the current position but the one contained in `this._expectedSeekingPosition`
+      pendingPosition = this._expectedSeekingPosition;
+    } else {
+      this._expectedSeekingPosition = null;
+    }
+    if (mediaTimings.seeking && previousObservation.seeking === 1 /* SeekingState.Internal */ && event !== "seeking") {
+      isInternalSeeking = true;
+    }
+    var rebufferingStatus = getRebufferingStatus(previousObservation, mediaTimings, tmpEvt, {
+      lowLatencyMode: this._lowLatencyMode,
+      withMediaSource: this._withMediaSource
     });
+    var freezingStatus = getFreezingStatus(previousObservation, mediaTimings, tmpEvt);
+    var seeking = isInternalSeeking ? 1 /* SeekingState.Internal */ : mediaTimings.seeking ? 2 /* SeekingState.External */ : 0 /* SeekingState.None */;
+    var timings = object_assign({}, mediaTimings, {
+      position: new ObservationPosition(mediaTimings.position, pendingPosition),
+      event: tmpEvt,
+      seeking: seeking,
+      rebuffering: rebufferingStatus,
+      freezing: freezingStatus
+    });
+    if (src_log.hasLevel("DEBUG")) {
+      src_log.debug("API: current media element state tick", "event", timings.event, "position", timings.position.getPolled(), "seeking", timings.seeking, "internalSeek", isInternalSeeking, "rebuffering", timings.rebuffering !== null, "freezing", timings.freezing !== null, "ended", timings.ended, "paused", timings.paused, "playbackRate", timings.playbackRate, "readyState", timings.readyState);
+    }
+    return timings;
+  };
+  _proto._generateObservationForEvent = function _generateObservationForEvent(event) {
+    var newObservation = this._getCurrentObservation(event);
+    if (src_log.hasLevel("DEBUG")) {
+      src_log.debug("API: current playback timeline:\n" + prettyPrintBuffered(newObservation.buffered, newObservation.position.getPolled()), "\n" + event);
+    }
+    this._observationRef.setValue(newObservation);
   };
   return PlaybackObserver;
 }();
+
+var ObservationPosition = /*#__PURE__*/function () {
+  function ObservationPosition(last, wanted) {
+    this._last = last;
+    this._wanted = wanted;
+  }
+  /**
+   * Returns the playback position actually observed on the media element at
+   * the time the playback observation was made.
+   *
+   * Note that it may be different than the position for which media data is
+   * wanted in rare scenarios where the goal position is not yet set on the
+   * media element.
+   *
+   * You should use this value when you want to obtain the actual position set
+   * on the media element for browser compatibility purposes. Note that this
+   * position was calculated at observation time, it might thus not be
+   * up-to-date if what you want is milliseconds-accuracy.
+   *
+   * If what you want is the actual position which the player is intended to
+   * play, you should rely on `getWanted` instead`.
+   * @returns {number}
+   */
+  var _proto2 = ObservationPosition.prototype;
+  _proto2.getPolled = function getPolled() {
+    return this._last;
+  }
+  /**
+   * Returns the position which the player should consider to load media data
+   * at the time the observation was made.
+   *
+   * It can be different than the value returned by `getPolled` in rare
+   * scenarios:
+   *
+   *   - When the initial position has not been set yet.
+   *
+   *   - When the current device do not let the RxPlayer peform precize seeks,
+   *     usually for perfomance reasons by seeking to a previous IDR frame
+   *     instead (for now only Tizen may be like this), in which case we
+   *     prefer to generally rely on the position wanted by the player (this
+   *     e.g. prevents issues where the RxPlayer logic and the device are
+   *     seeking back and forth in a loop).
+   *
+   *   - When a wanted position has been "forced" (@see forceWantedPosition).
+   * @returns {number}
+   */;
+  _proto2.getWanted = function getWanted() {
+    var _a;
+    return (_a = this._wanted) !== null && _a !== void 0 ? _a : this._last;
+  }
+  /**
+   * Method to call if you want to overwrite the currently wanted position.
+   * @param {number} pos
+   */;
+  _proto2.forceWantedPosition = function forceWantedPosition(pos) {
+    this._wanted = pos;
+  }
+  /**
+   * Returns `true` when the position wanted returned by `getWanted` and the
+   * actual position returned by `getPolled` may be different, meaning that
+   * we're currently not at the position we want to reach.
+   *
+   * This is a relatively rare situation which only happens when either the
+   * initial seek has not yet been performed. on specific targets where the
+   * seeking behavior is a little broken (@see getWanted) or when the wanted
+   * position has been forced (@see forceWantedPosition).
+   *
+   * In those situations, you might temporarily refrain from acting upon the
+   * actual current media position, as it may change soon.
+   *
+   * @returns {boolean}
+   */;
+  _proto2.isAwaitingFuturePosition = function isAwaitingFuturePosition() {
+    return this._wanted !== null;
+  };
+  return ObservationPosition;
+}();
 /**
  * Returns the amount of time in seconds the buffer should have ahead of the
  * current position before resuming playback. Based on the infos of the
@@ -5555,7 +5712,6 @@ var PlaybackObserver = /*#__PURE__*/function () {
  * @param {Boolean} lowLatencyMode
  * @returns {Number}
  */
-
 function getRebufferingEndGap(rebufferingStatus, lowLatencyMode) {
   if (rebufferingStatus === null) {
     return 0;
@@ -5592,10 +5748,9 @@ function hasLoadedUntilTheEnd(currentTime, currentRange, ended, duration, lowLat
 /**
  * Get basic playback information.
  * @param {HTMLMediaElement} mediaElement
- * @param {string} event
  * @returns {Object}
  */
-function getMediaInfos(mediaElement, event, withMediaSource) {
+function getMediaInfos(mediaElement, withMediaSource) {
   var buffered = mediaElement.buffered,
     currentTime = mediaElement.currentTime,
     duration = mediaElement.duration,
@@ -5630,8 +5785,7 @@ function getMediaInfos(mediaElement, event, withMediaSource) {
     paused: paused,
     playbackRate: playbackRate,
     readyState: readyState,
-    seeking: seeking,
-    event: event
+    seeking: seeking
   };
 }
 /**
@@ -5643,16 +5797,16 @@ function getMediaInfos(mediaElement, event, withMediaSource) {
  * @param {Object} currentInfo - Current set of basic information on the
  * `HTMLMediaElement`. This does not need every single property from a regular
  * playback observation.
+ * @param {string} currentEvt
  * @param {Object} options
  * @returns {Object|null}
  */
-function getRebufferingStatus(prevObservation, currentInfo, _ref) {
+function getRebufferingStatus(prevObservation, currentInfo, currentEvt, _ref) {
   var withMediaSource = _ref.withMediaSource,
     lowLatencyMode = _ref.lowLatencyMode;
   var _config$getCurrent4 = config.getCurrent(),
     REBUFFERING_GAP = _config$getCurrent4.REBUFFERING_GAP;
-  var currentEvt = currentInfo.event,
-    currentTime = currentInfo.position,
+  var currentTime = currentInfo.position,
     bufferGap = currentInfo.bufferGap,
     currentRange = currentInfo.currentRange,
     duration = currentInfo.duration,
@@ -5699,9 +5853,9 @@ function getRebufferingStatus(prevObservation, currentInfo, _ref) {
   // own, so we only try to detect when the media timestamp has not changed
   // between two consecutive timeupdates
   else {
-    if (canSwitchToRebuffering && (!paused && currentEvt === "timeupdate" && prevEvt === "timeupdate" && currentTime === prevTime || currentEvt === "seeking" && (bufferGap === Infinity || bufferGap === undefined && readyState < 3))) {
+    if (canSwitchToRebuffering && (!paused && currentEvt === "timeupdate" && prevEvt === "timeupdate" && currentTime === prevTime.getPolled() || currentEvt === "seeking" && (bufferGap === Infinity || bufferGap === undefined && readyState < 3))) {
       shouldRebuffer = true;
-    } else if (prevRebuffering !== null && (currentEvt !== "seeking" && currentTime !== prevTime || currentEvt === "canplay" || bufferGap === undefined && readyState >= 3 || bufferGap !== undefined && bufferGap < Infinity && (bufferGap > getRebufferingEndGap(prevRebuffering, lowLatencyMode) || fullyLoaded || ended))) {
+    } else if (prevRebuffering !== null && (currentEvt !== "seeking" && currentTime !== prevTime.getPolled() || currentEvt === "canplay" || bufferGap === undefined && readyState >= 3 || bufferGap !== undefined && bufferGap < Infinity && (bufferGap > getRebufferingEndGap(prevRebuffering, lowLatencyMode) || fullyLoaded || ended))) {
       shouldStopRebuffer = true;
     }
   }
@@ -5741,20 +5895,21 @@ function getRebufferingStatus(prevObservation, currentInfo, _ref) {
  * `null` if not.
  * @param {Object} prevObservation
  * @param {Object} currentInfo
+ * @param {string} currentEvt
  * @returns {Object|null}
  */
-function getFreezingStatus(prevObservation, currentInfo) {
+function getFreezingStatus(prevObservation, currentInfo, currentEvt) {
   var _config$getCurrent5 = config.getCurrent(),
     MINIMUM_BUFFER_AMOUNT_BEFORE_FREEZING = _config$getCurrent5.MINIMUM_BUFFER_AMOUNT_BEFORE_FREEZING;
   if (prevObservation.freezing) {
-    if (currentInfo.ended || currentInfo.paused || currentInfo.readyState === 0 || currentInfo.playbackRate === 0 || prevObservation.position !== currentInfo.position) {
+    if (currentInfo.ended || currentInfo.paused || currentInfo.readyState === 0 || currentInfo.playbackRate === 0 || prevObservation.position.getPolled() !== currentInfo.position) {
       return null; // Quit freezing status
     }
 
     return prevObservation.freezing; // Stay in it
   }
 
-  return currentInfo.event === "timeupdate" && currentInfo.bufferGap !== undefined && currentInfo.bufferGap > MINIMUM_BUFFER_AMOUNT_BEFORE_FREEZING && !currentInfo.ended && !currentInfo.paused && currentInfo.readyState >= 1 && currentInfo.playbackRate !== 0 && currentInfo.position === prevObservation.position ? {
+  return currentEvt === "timeupdate" && currentInfo.bufferGap !== undefined && currentInfo.bufferGap > MINIMUM_BUFFER_AMOUNT_BEFORE_FREEZING && !currentInfo.ended && !currentInfo.paused && currentInfo.readyState >= 1 && currentInfo.playbackRate !== 0 && currentInfo.position === prevObservation.position.getPolled() ? {
     timestamp: getMonotonicTimeStamp()
   } : null;
 }
@@ -5856,6 +6011,26 @@ function generateReadOnlyObserver(src, transform, cancellationSignal) {
     }
   };
 }
+/**
+ * Generate the initial playback observation for when no event has yet been
+ * emitted to lead to one.
+ * @param {HTMLMediaElement} mediaElement
+ * @param {boolean} withMediaSource
+ * @returns {Object}
+ */
+function getInitialObservation(mediaElement, withMediaSource) {
+  var mediaTimings = getMediaInfos(mediaElement, withMediaSource);
+  return object_assign(mediaTimings, {
+    rebuffering: null,
+    event: "init",
+    seeking: 0 /* SeekingState.None */,
+    position: {
+      last: mediaTimings.position,
+      pending: undefined
+    },
+    freezing: null
+  });
+}
 ;// CONCATENATED MODULE: ./src/core/api/track_management/track_dispatcher.ts
 
 
@@ -7074,7 +7249,7 @@ function emitSeekEvents(mediaElement, playbackObserver, onSeeking, onSeeked, can
   if (cancelSignal.isCancelled() || mediaElement === null) {
     return;
   }
-  var wasSeeking = playbackObserver.getReference().getValue().seeking;
+  var wasSeeking = playbackObserver.getReference().getValue().seeking === 2 /* SeekingState.External */;
   if (wasSeeking) {
     onSeeking();
     if (cancelSignal.isCancelled()) {
@@ -7299,7 +7474,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.2023111400";
+    _this.version = /* PLAYER_VERSION */"4.0.0-dev.2023121900";
     _this.log = src_log;
     _this.state = "STOPPED";
     _this.videoElement = videoElement;
@@ -7470,7 +7645,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,
@@ -7528,6 +7703,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
       };
@@ -7579,8 +7755,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,
@@ -7724,12 +7901,12 @@ var Player = /*#__PURE__*/function (_EventEmitter) {
         // keep previous metadata
         case "ENDED":
           _this2._priv_reloadingMetadata.reloadInPause = true;
-          _this2._priv_reloadingMetadata.reloadPosition = playbackObserver.getReference().getValue().position;
+          _this2._priv_reloadingMetadata.reloadPosition = playbackObserver.getReference().getValue().position.getPolled();
           break;
         default:
           var o = playbackObserver.getReference().getValue();
           _this2._priv_reloadingMetadata.reloadInPause = o.paused;
-          _this2._priv_reloadingMetadata.reloadPosition = o.position;
+          _this2._priv_reloadingMetadata.reloadPosition = o.position.getWanted();
           break;
       }
     };
@@ -8807,16 +8984,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");
@@ -8850,7 +9050,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!
@@ -8873,9 +9077,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;
     }
@@ -8887,9 +9091,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;
     }
@@ -9316,24 +9520,24 @@ var Player = /*#__PURE__*/function (_EventEmitter) {
     }
     var maximumPosition = manifest !== null ? manifest.getMaximumSafePosition() : undefined;
     var positionData = {
-      position: observation.position,
+      position: observation.position.getPolled(),
       duration: observation.duration,
       playbackRate: observation.playbackRate,
       maximumPosition: maximumPosition,
       // TODO bufferGap may be undefined
       bufferGap: observation.bufferGap === undefined || !isFinite(observation.bufferGap) ? 0 : observation.bufferGap
     };
-    if (manifest !== null && manifest.isLive && observation.position > 0) {
+    if (manifest !== null && manifest.isLive && observation.position.getPolled() > 0) {
       var ast = (_b = manifest.availabilityStartTime) !== null && _b !== void 0 ? _b : 0;
-      positionData.wallClockTime = observation.position + ast;
+      positionData.wallClockTime = observation.position.getPolled() + ast;
       var livePosition = manifest.getLivePosition();
       if (livePosition !== undefined) {
-        positionData.liveGap = livePosition - observation.position;
+        positionData.liveGap = livePosition - observation.position.getPolled();
       }
     } else if (isDirectFile && this.videoElement !== null) {
       var startDate = getStartDate(this.videoElement);
       if (startDate !== undefined) {
-        positionData.wallClockTime = startDate + observation.position;
+        positionData.wallClockTime = startDate + observation.position.getPolled();
       }
     }
     this.trigger("positionUpdate", positionData);
@@ -9506,7 +9710,7 @@ var Player = /*#__PURE__*/function (_EventEmitter) {
   }]);
   return Player;
 }(EventEmitter);
-Player.version = /* PLAYER_VERSION */"4.0.0-dev.2023111400";
+Player.version = /* PLAYER_VERSION */"4.0.0-dev.2023121900";
 /* harmony default export */ var public_api = (Player);
 ;// CONCATENATED MODULE: ./src/core/api/index.ts
 /**
@@ -10030,7 +10234,7 @@ function estimateStarvationModeBitrate(pendingRequests, playbackInfo, currentRep
     speed = playbackInfo.speed,
     position = playbackInfo.position;
   var realBufferGap = isFinite(bufferGap) ? bufferGap : 0;
-  var nextNeededPosition = position.last + realBufferGap;
+  var nextNeededPosition = position.getWanted() + realBufferGap;
   var concernedRequests = getConcernedRequests(pendingRequests, nextNeededPosition);
   if (concernedRequests.length !== 1) {
     // 0  == no request
@@ -10093,7 +10297,7 @@ function shouldDirectlySwitchToLowBitrate(playbackInfo, requests, lowLatencyMode
     return true;
   }
   var realBufferGap = isFinite(playbackInfo.bufferGap) ? playbackInfo.bufferGap : 0;
-  var nextNeededPosition = playbackInfo.position.last + realBufferGap;
+  var nextNeededPosition = playbackInfo.position.getWanted() + realBufferGap;
   var nextRequest = arrayFind(requests, function (_ref) {
     var content = _ref.content;
     return content.segment.duration > 0 && content.segment.time + content.segment.duration > nextNeededPosition;
@@ -10174,7 +10378,7 @@ var NetworkAnalyzer = /*#__PURE__*/function () {
     var _config$getCurrent2 = config.getCurrent(),
       ABR_STARVATION_DURATION_DELTA = _config$getCurrent2.ABR_STARVATION_DURATION_DELTA;
     // check if should get in/out of starvation mode
-    if (isNaN(duration) || realBufferGap + position.last < duration - ABR_STARVATION_DURATION_DELTA) {
+    if (isNaN(duration) || realBufferGap + position.getWanted() < duration - ABR_STARVATION_DURATION_DELTA) {
       if (!this._inStarvationMode && realBufferGap <= localConf.starvationGap) {
         src_log.info("ABR: enter starvation mode.");
         this._inStarvationMode = true;
@@ -11180,7 +11384,7 @@ function getEstimateReference(_ref, stopAllEstimates) {
         position = _lastPlaybackObservat.position,
         speed = _lastPlaybackObservat.speed;
       var timeRanges = val.buffered;
-      var bufferGap = getLeftSizeOfBufferedTimeRange(timeRanges, position.last);
+      var bufferGap = getLeftSizeOfBufferedTimeRange(timeRanges, position.getWanted());
       var representation = val.content.representation;
       var currentScore = scoreCalculator.getEstimate(representation);
       var currentBitrate = representation.bitrate;
@@ -11274,7 +11478,7 @@ function getEstimateReference(_ref, stopAllEstimates) {
        * `null` if not enabled or if there's currently no guess.
        */
       var chosenRepFromGuessMode = null;
-      if (lowLatencyMode && currentRepresentationVal !== null && context.manifest.isDynamic && maximumPosition - position.last < 40) {
+      if (lowLatencyMode && currentRepresentationVal !== null && context.manifest.isDynamic && maximumPosition - position.getWanted() < 40) {
         chosenRepFromGuessMode = guessBasedChooser.getGuess(sortedRepresentations, lastPlaybackObservation, currentRepresentationVal, currentBestBitrate, requests);
       }
       if (chosenRepFromGuessMode !== null && chosenRepFromGuessMode.bitrate > currentBestBitrate) {
@@ -11868,6 +12072,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.
@@ -11884,7 +12098,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;
 }
@@ -12340,7 +12564,7 @@ var Adaptation = /*#__PURE__*/function () {
         var reprObject = {
           id: representation.id,
           bitrate: representation.bitrate,
-          codec: representation.codec,
+          codecs: representation.codec === undefined ? [] : [representation.codec],
           height: representation.height,
           width: representation.width,
           frameRate: representation.frameRate,
@@ -13938,7 +14162,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.
@@ -14063,13 +14286,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);
@@ -14925,7 +15153,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.
@@ -15168,17 +15397,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
@@ -15825,7 +16057,7 @@ var SegmentInventory = /*#__PURE__*/function () {
         var removed = inventory.splice(indexBefore, numberOfSegmentToDelete);
         for (var _iterator = segment_inventory_createForOfIteratorHelperLoose(removed), _step; !(_step = _iterator()).done;) {
           var seg = _step.value;
-          if (seg.bufferedStart === undefined && seg.bufferedEnd === undefined) {
+          if (seg.bufferedStart === undefined && seg.bufferedEnd === undefined && seg.status !== 2 /* ChunkStatus.Failed */) {
             this._bufferedHistory.addBufferedSegment(seg.infos, null);
           }
         }
@@ -15878,7 +16110,7 @@ var SegmentInventory = /*#__PURE__*/function () {
       var _removed = inventory.splice(inventoryIndex, inventory.length - inventoryIndex);
       for (var _iterator2 = segment_inventory_createForOfIteratorHelperLoose(_removed), _step2; !(_step2 = _iterator2()).done;) {
         var _seg = _step2.value;
-        if (_seg.bufferedStart === undefined && _seg.bufferedEnd === undefined) {
+        if (_seg.bufferedStart === undefined && _seg.bufferedEnd === undefined && _seg.status !== 2 /* ChunkStatus.Failed */) {
           this._bufferedHistory.addBufferedSegment(_seg.infos, null);
         }
       }
@@ -15894,7 +16126,7 @@ var SegmentInventory = /*#__PURE__*/function () {
    * segment have been inserted, you should call the `completeSegment` method.
    * @param {Object} chunkInformation
    */;
-  _proto.insertChunk = function insertChunk(_ref) {
+  _proto.insertChunk = function insertChunk(_ref, succeed) {
     var period = _ref.period,
       adaptation = _ref.adaptation,
       representation = _ref.representation,
@@ -15912,7 +16144,7 @@ var SegmentInventory = /*#__PURE__*/function () {
     }
     var inventory = this._inventory;
     var newSegment = {
-      partiallyPushed: true,
+      status: succeed ? 0 /* ChunkStatus.PartiallyPushed */ : 2 /* ChunkStatus.Failed */,
       chunkSize: chunkSize,
       splitted: false,
       start: start,
@@ -16108,7 +16340,7 @@ var SegmentInventory = /*#__PURE__*/function () {
               //  ===>         : |--|====|-|
               src_log.warn("SI: Segment pushed is contained in a previous one", bufferType, start, end, segmentI.start, segmentI.end);
               var nextSegment = {
-                partiallyPushed: segmentI.partiallyPushed,
+                status: segmentI.status,
                 /**
                  * Note: this sadly means we're doing as if
                  * that chunk is present two times.
@@ -16261,7 +16493,10 @@ var SegmentInventory = /*#__PURE__*/function () {
           this._inventory.splice(firstI + 1, length);
           i -= length;
         }
-        this._inventory[firstI].partiallyPushed = false;
+        if (this._inventory[firstI].status === 0 /* ChunkStatus.PartiallyPushed */) {
+          this._inventory[firstI].status = 1 /* ChunkStatus.Complete */;
+        }
+
         this._inventory[firstI].chunkSize = segmentSize;
         this._inventory[firstI].end = lastEnd;
         this._inventory[firstI].bufferedEnd = lastBufferedEnd;
@@ -16276,10 +16511,12 @@ var SegmentInventory = /*#__PURE__*/function () {
       for (var _iterator3 = segment_inventory_createForOfIteratorHelperLoose(resSegments), _step3; !(_step3 = _iterator3()).done;) {
         var seg = _step3.value;
         if (seg.bufferedStart !== undefined && seg.bufferedEnd !== undefined) {
-          this._bufferedHistory.addBufferedSegment(seg.infos, {
-            start: seg.bufferedStart,
-            end: seg.bufferedEnd
-          });
+          if (seg.status !== 2 /* ChunkStatus.Failed */) {
+            this._bufferedHistory.addBufferedSegment(seg.infos, {
+              start: seg.bufferedStart,
+              end: seg.bufferedEnd
+            });
+          }
         } else {
           src_log.debug("SI: buffered range not known after sync. Skipping history.", seg.start, seg.end);
         }
@@ -16322,7 +16559,7 @@ var SegmentInventory = /*#__PURE__*/function () {
  */
 
 function bufferedStartLooksCoherent(thisSegment) {
-  if (thisSegment.bufferedStart === undefined || thisSegment.partiallyPushed) {
+  if (thisSegment.bufferedStart === undefined || thisSegment.status !== 1 /* ChunkStatus.Complete */) {
     return false;
   }
   var start = thisSegment.start,
@@ -16340,7 +16577,7 @@ function bufferedStartLooksCoherent(thisSegment) {
  * @returns {Boolean}
  */
 function bufferedEndLooksCoherent(thisSegment) {
-  if (thisSegment.bufferedEnd === undefined || thisSegment.partiallyPushed) {
+  if (thisSegment.bufferedEnd === undefined || thisSegment.status !== 1 /* ChunkStatus.Complete */) {
     return false;
   }
   var start = thisSegment.start,
@@ -16890,7 +17127,12 @@ var AudioVideoSegmentBuffer = /*#__PURE__*/function (_SegmentBuffer) {
     this._lastInitSegmentUniqueId = null; // initialize init segment as a security
     if (this._pendingTask !== null) {
       var error = err instanceof Error ? err : new Error("An unknown error occured when doing operations " + "on the SourceBuffer");
-      this._pendingTask.reject(error);
+      var task = this._pendingTask;
+      if (task.type === SegmentBufferOperation.Push && task.data.length === 0 && task.inventoryData !== null) {
+        this._segmentInventory.insertChunk(task.inventoryData, false);
+      }
+      this._pendingTask = null;
+      task.reject(error);
     }
   }
   /**
@@ -16941,7 +17183,7 @@ var AudioVideoSegmentBuffer = /*#__PURE__*/function (_SegmentBuffer) {
         switch (task.type) {
           case SegmentBufferOperation.Push:
             if (task.inventoryData !== null) {
-              this._segmentInventory.insertChunk(task.inventoryData);
+              this._segmentInventory.insertChunk(task.inventoryData, true);
             }
             break;
           case SegmentBufferOperation.EndOfSegment:
@@ -17773,8 +18015,7 @@ function BufferGarbageCollector(_ref, cancellationSignal) {
     maxBufferAhead = _ref.maxBufferAhead;
   var lastPosition;
   playbackObserver.listen(function (o) {
-    var _a;
-    lastPosition = (_a = o.position.pending) !== null && _a !== void 0 ? _a : o.position.last;
+    lastPosition = o.position.getWanted();
     clean();
   }, {
     includeLastObservation: true,
@@ -18883,7 +19124,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;
@@ -19107,7 +19348,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.
@@ -19156,14 +19397,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.
@@ -19216,7 +19457,7 @@ function getPlayableBufferedSegments(neededRange, segmentInventory) {
   for (var i = segmentInventory.length - 1; i >= 0; i--) {
     var eltInventory = segmentInventory[i];
     var representation = eltInventory.infos.representation;
-    if (!eltInventory.partiallyPushed && representation.decipherable !== false && representation.isSupported) {
+    if (eltInventory.status === 1 /* ChunkStatus.Complete */ && representation.decipherable !== false && representation.isSupported) {
       var inventorySegment = eltInventory.infos.segment;
       var eltInventoryStart = inventorySegment.time / inventorySegment.timescale;
       var eltInventoryEnd = !inventorySegment.complete ? eltInventory.end : eltInventoryStart + inventorySegment.duration / inventorySegment.timescale;
@@ -19400,7 +19641,7 @@ function appendSegmentToBuffer(_x, _x2, _x3, _x4) {
 }
 function _appendSegmentToBuffer() {
   _appendSegmentToBuffer = _asyncToGenerator( /*#__PURE__*/regenerator_default().mark(function _callee(playbackObserver, segmentBuffer, dataInfos, cancellationSignal) {
-    var _a, reason, _playbackObserver$get, position, currentPos, _reason;
+    var reason, _playbackObserver$get, position, currentPos, _reason;
     return regenerator_default().wrap(function _callee$(_context) {
       while (1) switch (_context.prev = _context.next) {
         case 0:
@@ -19429,7 +19670,7 @@ function _appendSegmentToBuffer() {
           });
         case 14:
           _playbackObserver$get = playbackObserver.getReference().getValue(), position = _playbackObserver$get.position;
-          currentPos = (_a = position.pending) !== null && _a !== void 0 ? _a : position.last;
+          currentPos = position.getWanted();
           _context.prev = 16;
           _context.next = 19;
           return forceGarbageCollection(currentPos, segmentBuffer, cancellationSignal);
@@ -19835,13 +20076,12 @@ function RepresentationStream(_ref, callbacks, parentCancelSignal) {
    * issues at the current time, calling the right callbacks if necessary.
    */
   function checkStatus() {
-    var _a, _b;
     if (segmentsLoadingCanceller.isUsed()) {
       return; // Stop all buffer status checking if load operations are stopped
     }
 
     var observation = playbackObserver.getReference().getValue();
-    var initialWantedTime = (_a = observation.position.pending) !== null && _a !== void 0 ? _a : observation.position.last;
+    var initialWantedTime = observation.position.getWanted();
     var status = getBufferStatus(content, initialWantedTime, playbackObserver, fastSwitchThreshold.getValue(), bufferGoal.getValue(), maxBufferSize.getValue(), segmentBuffer);
     var neededSegments = status.neededSegments;
     var neededInitSegment = null;
@@ -19852,7 +20092,7 @@ function RepresentationStream(_ref, callbacks, parentCancelSignal) {
       } else if (initSegmentState.isLoaded) {
         src_log.warn("Stream: Uninitialized index with an already loaded " + "initialization segment");
       } else {
-        var wantedStart = (_b = observation.position.pending) !== null && _b !== void 0 ? _b : observation.position.last;
+        var wantedStart = observation.position.getWanted();
         neededInitSegment = {
           segment: initSegmentState.segment,
           priority: getSegmentPriority(period.start, wantedStart)
@@ -19905,7 +20145,7 @@ function RepresentationStream(_ref, callbacks, parentCancelSignal) {
     }
     callbacks.streamStatusUpdate({
       period: period,
-      position: observation.position.last,
+      position: observation.position.getWanted(),
       bufferType: bufferType,
       imminentDiscontinuity: status.imminentDiscontinuity,
       isEmptyStream: false,
@@ -20173,22 +20413,30 @@ function getRepresentationsSwitchingStrategy(period, adaptation, settings, segme
       value: undefined
     };
   }
-  var currentTime = playbackObserver.getCurrentTime();
   var readyState = playbackObserver.getReadyState();
-  if (settings.switchingMode === "reload" &&
-  // We're playing the current Period
-  isTimeInRange({
-    start: start,
-    end: end
-  }, currentTime) &&
-  // There is data for the current position
-  readyState > 1 &&
-  // We're not playing the current wanted video Adaptation
-  !isTimeInRanges(rangesWithReps, currentTime)) {
-    return {
-      type: "needs-reload",
-      value: undefined
-    };
+  if (settings.switchingMode === "reload" && readyState > 1) {
+    var lastObservation = playbackObserver.getReference().getValue();
+    if (lastObservation.position.isAwaitingFuturePosition()) {
+      // We are not at the position we want to reach (e.g. initial seek, tizen
+      // seek-back...), just reload as checks here would be too complex
+      return {
+        type: "needs-reload",
+        value: undefined
+      };
+    } else {
+      var currentTime = playbackObserver.getCurrentTime();
+      if (isTimeInRange({
+        start: start,
+        end: end
+      }, currentTime) &&
+      // We're not playing the current wanted video Adaptation
+      !isTimeInRanges(rangesWithReps, currentTime)) {
+        return {
+          type: "needs-reload",
+          value: undefined
+        };
+      }
+    }
   }
   // From here, clean-up data from the previous Adaptation, if one
   var shouldFlush = settings.switchingMode === "direct";
@@ -20221,9 +20469,10 @@ function getRepresentationsSwitchingStrategy(period, adaptation, settings, segme
     if (paddingAfter == null) {
       paddingAfter = 0;
     }
+    var _currentTime = playbackObserver.getCurrentTime();
     rangesToExclude.push({
-      start: currentTime - paddingBefore,
-      end: currentTime + paddingAfter
+      start: _currentTime - paddingBefore,
+      end: _currentTime + paddingAfter
     });
   }
   // Now remove possible small range from the end if there is a segment from the
@@ -20851,10 +21100,10 @@ function areCodecsCompatible(a, b) {
  * @param {Object} segmentBuffer
  * @param {Object} period
  * @param {Object} adaptation
- * @param {Object} playbackInfo
+ * @param {Object} playbackObserver
  * @returns {Object}
  */
-function getAdaptationSwitchStrategy(segmentBuffer, period, adaptation, switchingMode, playbackInfo, options) {
+function getAdaptationSwitchStrategy(segmentBuffer, period, adaptation, switchingMode, playbackObserver, options) {
   if (segmentBuffer.codec !== undefined && options.onCodecSwitch === "reload" && !hasCompatibleCodec(adaptation, segmentBuffer.codec)) {
     return {
       type: "needs-reload",
@@ -20906,24 +21155,28 @@ function getAdaptationSwitchStrategy(segmentBuffer, period, adaptation, switchin
       value: undefined
     };
   }
-  var currentTime = playbackInfo.currentTime;
-  if (switchingMode === "reload" &&
-  // We're playing the current Period
-  isTimeInRange({
-    start: start,
-    end: end
-  }, currentTime) && (
-  // There is data for the current position or the codecs are differents
-  playbackInfo.readyState > 1 || !adaptation.getPlayableRepresentations().some(function (rep) {
-    var _a;
-    return are_codecs_compatible(rep.getMimeTypeString(), (_a = segmentBuffer.codec) !== null && _a !== void 0 ? _a : "");
-  })) &&
-  // We're not playing the current wanted video Adaptation
-  !isTimeInRanges(adaptationInBuffer, currentTime)) {
-    return {
-      type: "needs-reload",
-      value: undefined
-    };
+  var currentTime = playbackObserver.getCurrentTime();
+  var readyState = playbackObserver.getReadyState();
+  if (switchingMode === "reload" && readyState > 1) {
+    var lastObservation = playbackObserver.getReference().getValue();
+    if (lastObservation.position.isAwaitingFuturePosition()) {
+      // We are not at the position we want to reach (e.g. initial seek, tizen
+      // seek-back...), just reload as checks here would be too complex
+      return {
+        type: "needs-reload",
+        value: undefined
+      };
+    } else if (isTimeInRange({
+      start: start,
+      end: end
+    }, currentTime) &&
+    // We're not playing the current wanted video Adaptation
+    !isTimeInRanges(adaptationInBuffer, currentTime)) {
+      return {
+        type: "needs-reload",
+        value: undefined
+      };
+    }
   }
   // From here, clean-up data from the previous Adaptation, if one
   var shouldCleanAll = switchingMode === "direct";
@@ -21005,7 +21258,7 @@ function hasCompatibleCodec(adaptation, segmentBufferCodec) {
 /**
  * Returns buffered ranges of what we know correspond to the given `adaptation`
  * in the SegmentBuffer.
- * @param {Object} segmentBuffer
+ * @param {Array.<Object>} inventory
  * @param {Object} period
  * @param {Object} adaptation
  * @returns {Array.<Object>}
@@ -21123,7 +21376,7 @@ function PeriodStream(_ref, callbacks, parentCancelSignal) {
   adaptationRef.onUpdate(function (choice) {
     // As an IIFE to profit from async/await while respecting onUpdate's signature
     _asyncToGenerator( /*#__PURE__*/regenerator_default().mark(function _callee() {
-      var _a, streamCanceller, segmentBufferStatus, periodEnd, _config$getCurrent, DELTA_POSITION_AFTER_RELOAD, relativePosAfterSwitch, adaptation, representations, readyState, segmentBuffer, playbackInfos, strategy, _iterator3, _step3, _step3$value, start, end;
+      var _a, streamCanceller, segmentBufferStatus, periodEnd, _config$getCurrent, DELTA_POSITION_AFTER_RELOAD, relativePosAfterSwitch, adaptation, representations, segmentBuffer, strategy, _iterator3, _step3, _step3$value, start, end;
       return regenerator_default().wrap(function _callee$(_context) {
         while (1) switch (_context.prev = _context.next) {
           case 0:
@@ -21248,65 +21501,60 @@ function PeriodStream(_ref, callbacks, parentCancelSignal) {
             }
             return _context.abrupt("return");
           case 45:
-            readyState = playbackObserver.getReadyState();
             segmentBuffer = createOrReuseSegmentBuffer(segmentBuffersStore, bufferType, adaptation, options);
-            playbackInfos = {
-              currentTime: playbackObserver.getCurrentTime(),
-              readyState: readyState
-            };
-            strategy = getAdaptationSwitchStrategy(segmentBuffer, period, adaptation, choice.switchingMode, playbackInfos, options);
+            strategy = getAdaptationSwitchStrategy(segmentBuffer, period, adaptation, choice.switchingMode, playbackObserver, options);
             if (!(strategy.type === "needs-reload")) {
-              _context.next = 51;
+              _context.next = 49;
               break;
             }
             return _context.abrupt("return", askForMediaSourceReload(relativePosAfterSwitch, true, streamCanceller.signal));
-          case 51:
-            _context.next = 53;
+          case 49:
+            _context.next = 51;
             return segmentBuffersStore.waitForUsableBuffers(streamCanceller.signal);
-          case 53:
+          case 51:
             if (!streamCanceller.isUsed()) {
-              _context.next = 55;
+              _context.next = 53;
               break;
             }
             return _context.abrupt("return");
-          case 55:
+          case 53:
             if (!(strategy.type === "flush-buffer" || strategy.type === "clean-buffer")) {
-              _context.next = 69;
+              _context.next = 67;
               break;
             }
             _iterator3 = period_stream_createForOfIteratorHelperLoose(strategy.value);
-          case 57:
+          case 55:
             if ((_step3 = _iterator3()).done) {
-              _context.next = 65;
+              _context.next = 63;
               break;
             }
             _step3$value = _step3.value, start = _step3$value.start, end = _step3$value.end;
-            _context.next = 61;
+            _context.next = 59;
             return segmentBuffer.removeBuffer(start, end, streamCanceller.signal);
-          case 61:
+          case 59:
             if (!streamCanceller.isUsed()) {
-              _context.next = 63;
+              _context.next = 61;
               break;
             }
             return _context.abrupt("return");
-          case 63:
-            _context.next = 57;
+          case 61:
+            _context.next = 55;
             break;
-          case 65:
+          case 63:
             if (!(strategy.type === "flush-buffer")) {
-              _context.next = 69;
+              _context.next = 67;
               break;
             }
             callbacks.needsBufferFlush();
             if (!streamCanceller.isUsed()) {
-              _context.next = 69;
+              _context.next = 67;
               break;
             }
             return _context.abrupt("return");
-          case 69:
+          case 67:
             garbageCollectors.get(segmentBuffer)(streamCanceller.signal);
             createAdaptationStream(adaptation, representations, segmentBuffer, streamCanceller.signal);
-          case 71:
+          case 69:
           case "end":
             return _context.stop();
         }
@@ -21464,7 +21712,7 @@ function createAdaptationStreamPlaybackObserver(initialPlaybackObserver, segment
     function constructAdaptationStreamPlaybackObservation() {
       var baseObservation = observationRef.getValue();
       var buffered = segmentBuffer.getBufferedRanges();
-      var bufferGap = getLeftSizeOfBufferedTimeRange(buffered, baseObservation.position.last);
+      var bufferGap = getLeftSizeOfBufferedTimeRange(buffered, baseObservation.position.getWanted());
       return object_assign({}, baseObservation, {
         bufferGap: bufferGap
       });
@@ -21500,7 +21748,7 @@ function createEmptyAdaptationStream(playbackObserver, wantedBufferAhead, buffer
   function sendStatus() {
     var observation = playbackObserver.getReference().getValue();
     var wba = wantedBufferAhead.getValue();
-    var position = observation.position.last;
+    var position = observation.position.getWanted();
     if (period.end !== undefined && position + wba >= period.end) {
       src_log.debug("Stream: full \"empty\" AdaptationStream", bufferType);
       hasFinishedLoading = true;
@@ -21508,8 +21756,8 @@ function createEmptyAdaptationStream(playbackObserver, wantedBufferAhead, buffer
     callbacks.streamStatusUpdate({
       period: period,
       bufferType: bufferType,
-      position: position,
       imminentDiscontinuity: null,
+      position: position,
       isEmptyStream: true,
       hasFinishedLoading: hasFinishedLoading,
       neededSegments: []
@@ -21683,14 +21931,16 @@ function StreamOrchestrator(content, playbackObserver, representationEstimator,
     wantedBufferAhead = options.wantedBufferAhead,
     maxVideoBufferSize = options.maxVideoBufferSize;
   var _config$getCurrent = config.getCurrent(),
+    MINIMUM_MAX_BUFFER_AHEAD = _config$getCurrent.MINIMUM_MAX_BUFFER_AHEAD,
     MAXIMUM_MAX_BUFFER_AHEAD = _config$getCurrent.MAXIMUM_MAX_BUFFER_AHEAD,
     MAXIMUM_MAX_BUFFER_BEHIND = _config$getCurrent.MAXIMUM_MAX_BUFFER_BEHIND;
   // Keep track of a unique BufferGarbageCollector created per
   // SegmentBuffer.
   var garbageCollectors = new WeakMapMemory(function (segmentBuffer) {
+    var _a, _b;
     var bufferType = segmentBuffer.bufferType;
-    var defaultMaxBehind = MAXIMUM_MAX_BUFFER_BEHIND[bufferType] != null ? MAXIMUM_MAX_BUFFER_BEHIND[bufferType] : Infinity;
-    var defaultMaxAhead = MAXIMUM_MAX_BUFFER_AHEAD[bufferType] != null ? MAXIMUM_MAX_BUFFER_AHEAD[bufferType] : Infinity;
+    var defaultMaxBehind = (_a = MAXIMUM_MAX_BUFFER_BEHIND[bufferType]) !== null && _a !== void 0 ? _a : Infinity;
+    var maxAheadHigherBound = (_b = MAXIMUM_MAX_BUFFER_AHEAD[bufferType]) !== null && _b !== void 0 ? _b : Infinity;
     return function (gcCancelSignal) {
       BufferGarbageCollector({
         segmentBuffer: segmentBuffer,
@@ -21699,7 +21949,9 @@ function StreamOrchestrator(content, playbackObserver, representationEstimator,
           return Math.min(val, defaultMaxBehind);
         }, gcCancelSignal),
         maxBufferAhead: createMappedReference(maxBufferAhead, function (val) {
-          return Math.min(val, defaultMaxAhead);
+          var _a;
+          var lowerBound = Math.max(val, (_a = MINIMUM_MAX_BUFFER_AHEAD[bufferType]) !== null && _a !== void 0 ? _a : 0);
+          return Math.min(lowerBound, maxAheadHigherBound);
         }, gcCancelSignal)
       }, gcCancelSignal);
     };
@@ -21738,8 +21990,8 @@ function StreamOrchestrator(content, playbackObserver, representationEstimator,
     // than the ones already considered
     playbackObserver.listen(function (_ref) {
       var position = _ref.position;
-      var _a, _b;
-      var time = (_a = position.pending) !== null && _a !== void 0 ? _a : position.last;
+      var _a;
+      var time = position.getWanted();
       if (!enableOutOfBoundsCheck || !isOutOfPeriodList(time)) {
         return;
       }
@@ -21757,7 +22009,7 @@ function StreamOrchestrator(content, playbackObserver, representationEstimator,
       currentCanceller.cancel();
       currentCanceller = new TaskCanceller();
       currentCanceller.linkToSignal(orchestratorCancelSignal);
-      var nextPeriod = (_b = manifest.getPeriodForTime(time)) !== null && _b !== void 0 ? _b : manifest.getNextPeriod(time);
+      var nextPeriod = (_a = manifest.getPeriodForTime(time)) !== null && _a !== void 0 ? _a : manifest.getNextPeriod(time);
       if (nextPeriod === undefined) {
         src_log.warn("Stream: The wanted position is not found in the Manifest.");
         return;
@@ -21929,7 +22181,6 @@ function StreamOrchestrator(content, playbackObserver, representationEstimator,
               // to reduce the risk of race conditions where the next observation
               // was going to be emitted synchronously.
               queue_microtask(function () {
-                var _a;
                 if (orchestratorCancelSignal.isCancelled()) {
                   return;
                 }
@@ -21946,7 +22197,7 @@ function StreamOrchestrator(content, playbackObserver, representationEstimator,
                     return;
                   }
                 }
-                var lastPosition = (_a = observation.position.pending) !== null && _a !== void 0 ? _a : observation.position.last;
+                var lastPosition = observation.position.getWanted();
                 var newInitialPeriod = manifest.getPeriodForTime(lastPosition);
                 if (newInitialPeriod == null) {
                   callbacks.error(new MediaError("MEDIA_TIME_NOT_FOUND", "The wanted position is not found in the Manifest."));
@@ -22008,9 +22259,8 @@ function StreamOrchestrator(content, playbackObserver, representationEstimator,
     // that Period.
     playbackObserver.listen(function (_ref2, stopListeningObservations) {
       var position = _ref2.position;
-      var _a, _b;
-      if (basePeriod.end !== undefined && ((_a = position.pending) !== null && _a !== void 0 ? _a : position.last) >= basePeriod.end) {
-        src_log.info("Stream: Destroying PeriodStream as the current playhead moved above it", bufferType, basePeriod.start, (_b = position.pending) !== null && _b !== void 0 ? _b : position.last, basePeriod.end);
+      if (basePeriod.end !== undefined && position.getWanted() >= basePeriod.end) {
+        src_log.info("Stream: Destroying PeriodStream as the current playhead moved above it", bufferType, basePeriod.start, position.getWanted(), basePeriod.end);
         stopListeningObservations();
         consecutivePeriodStreamCb.periodStreamCleared({
           type: bufferType,
@@ -22162,7 +22412,7 @@ function needsFlushingAfterClean(observation, cleanedRanges) {
   if (cleanedRanges.length === 0) {
     return false;
   }
-  var curPos = observation.position.last;
+  var curPos = observation.position.getPolled();
   // Based on the playback direction, we just check whether we may encounter
   // the corresponding ranges, without seeking or re-switching playback
   // direction which is expected to lead to a low-level flush anyway.
@@ -22270,8 +22520,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
@@ -22303,8 +22553,7 @@ var ContentTimeBoundariesObserver = /*#__PURE__*/function (_EventEmitter) {
     var cancelSignal = _this._canceller.signal;
     playbackObserver.listen(function (_ref) {
       var position = _ref.position;
-      var _a;
-      var wantedPosition = (_a = position.pending) !== null && _a !== void 0 ? _a : position.last;
+      var wantedPosition = position.getWanted();
       if (wantedPosition < manifest.getMinimumSafePosition()) {
         var warning = new MediaError("MEDIA_TIME_BEFORE_MANIFEST", "The current position is behind the " + "earliest time announced in the Manifest.");
         _this.trigger("warning", warning);
@@ -22317,7 +22566,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;
       }
@@ -22326,12 +22575,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.
@@ -22357,14 +22607,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);
         }
       }
     }
@@ -22504,14 +22754,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) {
@@ -22588,9 +22838,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();
@@ -22920,10 +23169,8 @@ function openMediaSource(mediaElement, unlinkSignal) {
 function createStreamPlaybackObserver(srcPlaybackObserver, _ref, fnCancelSignal) {
   var autoPlay = _ref.autoPlay,
     initialPlayPerformed = _ref.initialPlayPerformed,
-    initialSeekPerformed = _ref.initialSeekPerformed,
     manifest = _ref.manifest,
-    speed = _ref.speed,
-    startTime = _ref.startTime;
+    speed = _ref.speed;
   return srcPlaybackObserver.deriveReadOnlyObserver(function transform(observationRef, parentObserverCancelSignal) {
     var canceller = new TaskCanceller();
     canceller.linkToSignal(parentObserverCancelSignal);
@@ -22941,10 +23188,7 @@ function createStreamPlaybackObserver(srcPlaybackObserver, _ref, fnCancelSignal)
     function constructStreamPlaybackObservation() {
       var observation = observationRef.getValue();
       var lastSpeed = speed.getValue();
-      var pendingPosition;
-      if (!initialSeekPerformed.getValue()) {
-        pendingPosition = startTime;
-      } else if (!manifest.isDynamic || manifest.isLastPeriodKnown) {
+      if (!manifest.isDynamic || manifest.isLastPeriodKnown) {
         // HACK: When the position is actually further than the maximum
         // position for a finished content, we actually want to be loading
         // the last segment before ending.
@@ -22952,17 +23196,23 @@ function createStreamPlaybackObserver(srcPlaybackObserver, _ref, fnCancelSignal)
         // want to seek one second before the period's end (despite never
         // doing it).
         var lastPeriod = manifest.periods[manifest.periods.length - 1];
-        if (lastPeriod !== undefined && lastPeriod.end !== undefined && observation.position > lastPeriod.end) {
-          pendingPosition = lastPeriod.end - 1;
+        if (lastPeriod !== undefined && lastPeriod.end !== undefined) {
+          var wantedPosition = observation.position.getWanted();
+          if (wantedPosition >= lastPeriod.start && wantedPosition >= lastPeriod.end - 1) {
+            // We're after the end of the last Period, check if `buffered`
+            // indicates that the last segment is probably not loaded, in which
+            // case act as if we want to load one second before the end.
+            var buffered = observation.buffered;
+            if (buffered.length === 0 || buffered.end(buffered.length - 1) < observation.duration - 1) {
+              observation.position.forceWantedPosition(lastPeriod.end - 1);
+            }
+          }
         }
       }
       return {
         // TODO more exact according to the current Adaptation chosen?
         maximumPosition: manifest.getMaximumSafePosition(),
-        position: {
-          last: observation.position,
-          pending: pendingPosition
-        },
+        position: observation.position,
         duration: observation.duration,
         paused: {
           last: observation.paused,
@@ -23106,15 +23356,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);
@@ -23131,6 +23376,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;
@@ -23319,116 +23569,156 @@ function getLoadedReference(playbackObserver, mediaElement, isDirectfile, cancel
 
 
 
-
 /**
  * Seek as soon as possible at the initially wanted position and play if
  * autoPlay is wanted.
- * @param {HTMLMediaElement} mediaElement
- * @param {Object} playbackObserver
- * @param {number|Function} startTime
- * @param {boolean} mustAutoPlay
- * @param {Function} onWarning
+ * @param {Object} args
  * @param {Object} cancelSignal
  * @returns {Object}
  */
-function performInitialSeekAndPlay(mediaElement, playbackObserver, startTime, mustAutoPlay, onWarning, cancelSignal) {
-  var resolveAutoPlay;
-  var rejectAutoPlay;
-  var autoPlayResult = new Promise(function (res, rej) {
-    resolveAutoPlay = res;
-    rejectAutoPlay = rej;
-  });
-  var initialSeekPerformed = new utils_reference(false, cancelSignal);
+function performInitialSeekAndPlay(_ref, cancelSignal) {
+  var mediaElement = _ref.mediaElement,
+    playbackObserver = _ref.playbackObserver,
+    startTime = _ref.startTime,
+    mustAutoPlay = _ref.mustAutoPlay,
+    isDirectfile = _ref.isDirectfile,
+    onWarning = _ref.onWarning;
   var initialPlayPerformed = new utils_reference(false, cancelSignal);
-  mediaElement.addEventListener("loadedmetadata", onLoadedMetadata);
-  var deregisterCancellation = cancelSignal.register(function (err) {
-    mediaElement.removeEventListener("loadedmetadata", onLoadedMetadata);
-    rejectAutoPlay(err);
-  });
-  if (mediaElement.readyState >= READY_STATES.HAVE_METADATA) {
-    onLoadedMetadata();
-  }
-  return {
-    autoPlayResult: autoPlayResult,
-    initialPlayPerformed: initialPlayPerformed,
-    initialSeekPerformed: initialSeekPerformed
-  };
-  function onLoadedMetadata() {
-    mediaElement.removeEventListener("loadedmetadata", onLoadedMetadata);
-    var initialTime = typeof startTime === "function" ? startTime() : startTime;
-    src_log.info("Init: Set initial time", initialTime);
-    playbackObserver.setCurrentTime(initialTime);
-    initialSeekPerformed.setValue(true);
-    initialSeekPerformed.finish();
-    if (shouldValidateMetadata() && mediaElement.duration === 0) {
-      var error = new MediaError("MEDIA_ERR_NOT_LOADED_METADATA", "Cannot load automatically: your browser " + "falsely announced having loaded the content.");
-      onWarning(error);
-    }
-    if (cancelSignal.isCancelled()) {
-      return;
+  var autoPlayResult = new Promise(function (resolveAutoPlay, rejectAutoPlay) {
+    // `startTime` defined as a function might depend on metadata to make its
+    // choice, such as the content duration, minimum and/or maximum position.
+    //
+    // The RxPlayer might already know those through the Manifest file for
+    // non-Directfile contents, yet only through the `HTMLMediaElement` once a
+    // a sufficient `readyState` has been reached for directfile contents.
+    // So let's divide the two possibilities here.
+    if (!isDirectfile || typeof startTime === "number") {
+      playbackObserver.setCurrentTime(typeof startTime === "number" ? startTime : startTime());
+      waitForSeekable();
+    } else {
+      playbackObserver.listen(function (obs, stopListening) {
+        if (obs.readyState >= 1) {
+          stopListening();
+          playbackObserver.setCurrentTime(typeof startTime === "number" ? startTime : startTime());
+          waitForSeekable();
+        }
+      }, {
+        includeLastObservation: true,
+        clearSignal: cancelSignal
+      });
     }
-    playbackObserver.listen(function (observation, stopListening) {
-      if (!observation.seeking && observation.rebuffering === null && observation.readyState >= 1) {
-        stopListening();
-        onPlayable();
-      }
-    }, {
-      includeLastObservation: true,
-      clearSignal: cancelSignal
+    var deregisterCancellation = cancelSignal.register(function (err) {
+      rejectAutoPlay(err);
     });
-  }
-  function onPlayable() {
-    var _a;
-    src_log.info("Init: Can begin to play content");
-    if (!mustAutoPlay) {
-      if (mediaElement.autoplay) {
-        src_log.warn("Init: autoplay is enabled on HTML media element. " + "Media will play as soon as possible.");
-      }
-      initialPlayPerformed.setValue(true);
-      initialPlayPerformed.finish();
-      deregisterCancellation();
-      return resolveAutoPlay({
-        type: "skipped"
+    /**
+     * Logic that should be run once the initial seek has been asked to the
+     * PlaybackObserver.
+     *
+     * Actually wait until the seek has been performed, wait for the right moment
+     * to perform autoplay, resolve the promise once everything has been done and
+     * potentially send warning if a minor issue is detected.
+     */
+    function waitForSeekable() {
+      playbackObserver.listen(function (obs, stopListening) {
+        if (obs.seeking === 0 /* SeekingState.None */ || obs.readyState === 0) {
+          return;
+        }
+        stopListening();
+        if (shouldValidateMetadata() && mediaElement.duration === 0) {
+          var error = new MediaError("MEDIA_ERR_NOT_LOADED_METADATA", "Cannot load automatically: your browser " + "falsely announced having loaded the content.");
+          onWarning(error);
+        }
+        if (cancelSignal.isCancelled()) {
+          return;
+        }
+        waitForPlayable();
+      }, {
+        includeLastObservation: true,
+        clearSignal: cancelSignal
       });
     }
-    var playResult;
-    try {
-      playResult = (_a = mediaElement.play()) !== null && _a !== void 0 ? _a : Promise.resolve();
-    } catch (playError) {
-      deregisterCancellation();
-      return rejectAutoPlay(playError);
+    /**
+     * Logic that should be run once the initial seek has been properly performed.
+     *
+     * Wait for the media being playable before performing the autoplay operation
+     * if asked. Potentially send warning if a minor issue has been detected while
+     * doing so.
+     */
+    function waitForPlayable() {
+      playbackObserver.listen(function (observation, stopListening) {
+        if (observation.seeking === 0 /* SeekingState.None */ && observation.rebuffering === null && observation.readyState >= 1) {
+          stopListening();
+          onPlayable();
+        }
+      }, {
+        includeLastObservation: true,
+        clearSignal: cancelSignal
+      });
     }
-    playResult.then(function () {
-      if (cancelSignal.isCancelled()) {
-        return;
+    /**
+     * Callback called once the content is considered "playable".
+     *
+     * Perform the autoplay if needed, handling potential issues and resolve the
+     * Promise when done.
+     * Might also send warnings if minor issues arise.
+     */
+    function onPlayable() {
+      var _a;
+      src_log.info("Init: Can begin to play content");
+      if (!mustAutoPlay) {
+        if (mediaElement.autoplay) {
+          src_log.warn("Init: autoplay is enabled on HTML media element. " + "Media will play as soon as possible.");
+        }
+        initialPlayPerformed.setValue(true);
+        initialPlayPerformed.finish();
+        deregisterCancellation();
+        return resolveAutoPlay({
+          type: "skipped"
+        });
       }
-      initialPlayPerformed.setValue(true);
-      initialPlayPerformed.finish();
-      deregisterCancellation();
-      return resolveAutoPlay({
-        type: "autoplay"
-      });
-    })["catch"](function (playError) {
-      deregisterCancellation();
-      if (cancelSignal.isCancelled()) {
-        return;
+      var playResult;
+      try {
+        playResult = (_a = mediaElement.play()) !== null && _a !== void 0 ? _a : Promise.resolve();
+      } catch (playError) {
+        deregisterCancellation();
+        return rejectAutoPlay(playError);
       }
-      if (playError instanceof Error && playError.name === "NotAllowedError") {
-        // auto-play was probably prevented.
-        src_log.warn("Init: Media element can't play." + " It may be due to browser auto-play policies.");
-        var error = new MediaError("MEDIA_ERR_BLOCKED_AUTOPLAY", "Cannot trigger auto-play automatically: " + "your browser does not allow it.");
-        onWarning(error);
+      playResult.then(function () {
         if (cancelSignal.isCancelled()) {
           return;
         }
+        initialPlayPerformed.setValue(true);
+        initialPlayPerformed.finish();
+        deregisterCancellation();
         return resolveAutoPlay({
-          type: "autoplay-blocked"
+          type: "autoplay"
         });
-      } else {
-        rejectAutoPlay(playError);
-      }
-    });
-  }
+      })["catch"](function (playError) {
+        deregisterCancellation();
+        if (cancelSignal.isCancelled()) {
+          return;
+        }
+        if (playError instanceof Error && playError.name === "NotAllowedError") {
+          // auto-play was probably prevented.
+          src_log.warn("Init: Media element can't play." + " It may be due to browser auto-play policies.");
+          var error = new MediaError("MEDIA_ERR_BLOCKED_AUTOPLAY", "Cannot trigger auto-play automatically: " + "your browser does not allow it.");
+          onWarning(error);
+          if (cancelSignal.isCancelled()) {
+            return;
+          }
+          return resolveAutoPlay({
+            type: "autoplay-blocked"
+          });
+        } else {
+          rejectAutoPlay(playError);
+        }
+      });
+    }
+  });
+  return {
+    autoPlayResult: autoPlayResult,
+    initialPlayPerformed: initialPlayPerformed
+  };
 }
 ;// CONCATENATED MODULE: ./src/core/decrypt/types.ts
 /**
@@ -23910,36 +24200,6 @@ function getMaximumLiveSeekablePosition(contentLastPosition) {
   // authorize exceptionally going over it.
   return Math.max(Math.pow(2, 32), contentLastPosition + YEAR_IN_SECONDS);
 }
-;// CONCATENATED MODULE: ./src/compat/is_seeking_approximate.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.
- */
-
-/**
- * On some devices (right now only seen on Tizen), seeking through the
- * `currentTime` property can lead to the browser re-seeking once the
- * segments have been loaded to improve seeking performances (for
- * example, by seeking right to an intra video frame).
- *
- * This can lead to conflicts with the RxPlayer code.
- *
- * This boolean is only `true` on the devices where this behavior has been
- * observed.
- */
-var isSeekingApproximate = isTizen;
-/* harmony default export */ var is_seeking_approximate = (isSeekingApproximate);
 ;// CONCATENATED MODULE: ./src/core/init/utils/rebuffering_controller.ts
 
 function rebuffering_controller_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 = rebuffering_controller_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."); }
@@ -23967,7 +24227,6 @@ function rebuffering_controller_arrayLikeToArray(arr, len) { if (len == null ||
 
 
 
-
 /**
  * Work-around rounding errors with floating points by setting an acceptable,
  * very short, deviation when checking equalities.
@@ -24008,38 +24267,12 @@ var RebufferingController = /*#__PURE__*/function (_EventEmitter) {
       return;
     }
     this._isStarted = true;
-    /**
-     * On some devices (right now only seen on Tizen), seeking through the
-     * `currentTime` property can lead to the browser re-seeking once the
-     * segments have been loaded to improve seeking performances (for
-     * example, by seeking right to an intra video frame).
-     * In that case, we risk being in a conflict with that behavior: if for
-     * example we encounter a small discontinuity at the position the browser
-     * seeks to, we will seek over it, the browser would seek back and so on.
-     *
-     * This variable allows to store the last known position we were seeking to
-     * so we can detect when the browser seeked back (to avoid performing another
-     * seek after that). When browsers seek back to a position behind a
-     * discontinuity, they are usually able to skip them without our help.
-     */
-    var lastSeekingPosition;
-    /**
-     * In some conditions (see `lastSeekingPosition`), we might want to not
-     * automatically seek over discontinuities because the browser might do it
-     * itself instead.
-     * In that case, we still want to perform the seek ourselves if the browser
-     * doesn't do it after sufficient time.
-     * This variable allows to store the timestamp at which a discontinuity began
-     * to be ignored.
-     */
-    var ignoredStallTimeStamp = null;
     var playbackRateUpdater = new PlaybackRateUpdater(this._playbackObserver, this._speed);
     this._canceller.signal.register(function () {
       playbackRateUpdater.dispose();
     });
     var prevFreezingState = null;
     this._playbackObserver.listen(function (observation) {
-      var _a;
       var discontinuitiesStore = _this2._discontinuitiesStore;
       var buffered = observation.buffered,
         position = observation.position,
@@ -24048,31 +24281,24 @@ var RebufferingController = /*#__PURE__*/function (_EventEmitter) {
         freezing = observation.freezing;
       var _config$getCurrent = config.getCurrent(),
         BUFFER_DISCONTINUITY_THRESHOLD = _config$getCurrent.BUFFER_DISCONTINUITY_THRESHOLD,
-        FORCE_DISCONTINUITY_SEEK_DELAY = _config$getCurrent.FORCE_DISCONTINUITY_SEEK_DELAY,
         FREEZING_STALLED_DELAY = _config$getCurrent.FREEZING_STALLED_DELAY,
         UNFREEZING_SEEK_DELAY = _config$getCurrent.UNFREEZING_SEEK_DELAY,
         UNFREEZING_DELTA_POSITION = _config$getCurrent.UNFREEZING_DELTA_POSITION;
-      if (!observation.seeking && is_seeking_approximate && ignoredStallTimeStamp === null && lastSeekingPosition !== null && observation.position < lastSeekingPosition) {
-        src_log.debug("Init: the device appeared to have seeked back by itself.");
-        var now = getMonotonicTimeStamp();
-        ignoredStallTimeStamp = now;
-      }
-      lastSeekingPosition = observation.seeking ? Math.max((_a = observation.pendingInternalSeek) !== null && _a !== void 0 ? _a : 0, observation.position) : null;
       if (_this2._checkDecipherabilityFreeze(observation)) {
         return;
       }
       if (freezing !== null) {
-        var _now = getMonotonicTimeStamp();
+        var now = getMonotonicTimeStamp();
         var referenceTimestamp = prevFreezingState === null ? freezing.timestamp : prevFreezingState.attemptTimestamp;
-        if (_now - referenceTimestamp > UNFREEZING_SEEK_DELAY) {
+        if (!position.isAwaitingFuturePosition() && now - referenceTimestamp > UNFREEZING_SEEK_DELAY) {
           src_log.warn("Init: trying to seek to un-freeze player");
           _this2._playbackObserver.setCurrentTime(_this2._playbackObserver.getCurrentTime() + UNFREEZING_DELTA_POSITION);
           prevFreezingState = {
-            attemptTimestamp: _now
+            attemptTimestamp: now
           };
         }
-        if (_now - freezing.timestamp > FREEZING_STALLED_DELAY) {
-          if (rebuffering === null || ignoredStallTimeStamp !== null) {
+        if (now - freezing.timestamp > FREEZING_STALLED_DELAY) {
+          if (rebuffering === null) {
             playbackRateUpdater.stopRebuffering();
           } else {
             playbackRateUpdater.startRebuffering();
@@ -24089,8 +24315,8 @@ var RebufferingController = /*#__PURE__*/function (_EventEmitter) {
           // With a readyState set to 1, we should still not be able to play:
           // Return that we're stalled
           var reason;
-          if (observation.seeking) {
-            reason = observation.pendingInternalSeek !== null ? "internal-seek" : "seeking";
+          if (observation.seeking !== 0 /* SeekingState.None */) {
+            reason = observation.seeking === 1 /* SeekingState.Internal */ ? "internal-seek" : "seeking";
           } else {
             reason = "not-ready";
           }
@@ -24102,19 +24328,13 @@ var RebufferingController = /*#__PURE__*/function (_EventEmitter) {
       }
       // We want to separate a stall situation when a seek is due to a seek done
       // internally by the player to when its due to a regular user seek.
-      var stalledReason = rebuffering.reason === "seeking" && observation.pendingInternalSeek !== null ? "internal-seek" : rebuffering.reason;
-      if (ignoredStallTimeStamp !== null) {
-        var _now2 = getMonotonicTimeStamp();
-        if (_now2 - ignoredStallTimeStamp < FORCE_DISCONTINUITY_SEEK_DELAY) {
-          playbackRateUpdater.stopRebuffering();
-          src_log.debug("Init: letting the device get out of a stall by itself");
-          _this2.trigger("stalled", stalledReason);
-          return;
-        } else {
-          src_log.warn("Init: ignored stall for too long, considering it", _now2 - ignoredStallTimeStamp);
-        }
+      var stalledReason = rebuffering.reason === "seeking" && observation.seeking === 1 /* SeekingState.Internal */ ? "internal-seek" : rebuffering.reason;
+      if (position.isAwaitingFuturePosition()) {
+        playbackRateUpdater.stopRebuffering();
+        src_log.debug("Init: let rebuffering happen as we're awaiting a future position");
+        _this2.trigger("stalled", stalledReason);
+        return;
       }
-      ignoredStallTimeStamp = null;
       playbackRateUpdater.startRebuffering();
       if (_this2._manifest === null) {
         _this2.trigger("stalled", stalledReason);
@@ -24129,14 +24349,14 @@ var RebufferingController = /*#__PURE__*/function (_EventEmitter) {
           if (realSeekTime <= _this2._playbackObserver.getCurrentTime()) {
             src_log.info("Init: position to seek already reached, no seeking", _this2._playbackObserver.getCurrentTime(), realSeekTime);
           } else {
-            src_log.warn("SA: skippable discontinuity found in the stream", position, realSeekTime);
+            src_log.warn("SA: skippable discontinuity found in the stream", position.getPolled(), realSeekTime);
             _this2._playbackObserver.setCurrentTime(realSeekTime);
             _this2.trigger("warning", generateDiscontinuityError(stalledPosition, realSeekTime));
             return;
           }
         }
       }
-      var freezePosition = stalledPosition !== null && stalledPosition !== void 0 ? stalledPosition : position;
+      var positionBlockedAt = stalledPosition !== null && stalledPosition !== void 0 ? stalledPosition : position.getPolled();
       // Is it a very short discontinuity in buffer ? -> Seek at the beginning of the
       //                                                 next range
       //
@@ -24144,13 +24364,13 @@ var RebufferingController = /*#__PURE__*/function (_EventEmitter) {
       // calculate a stalled state. This is useful for some
       // implementation that might drop an injected segment, or in
       // case of small discontinuity in the content.
-      var nextBufferRangeGap = getNextBufferedTimeRangeGap(buffered, freezePosition);
+      var nextBufferRangeGap = getNextBufferedTimeRangeGap(buffered, positionBlockedAt);
       if (_this2._speed.getValue() > 0 && nextBufferRangeGap < BUFFER_DISCONTINUITY_THRESHOLD) {
-        var seekTo = freezePosition + nextBufferRangeGap + rebuffering_controller_EPSILON;
+        var seekTo = positionBlockedAt + nextBufferRangeGap + rebuffering_controller_EPSILON;
         if (_this2._playbackObserver.getCurrentTime() < seekTo) {
-          src_log.warn("Init: discontinuity encountered inferior to the threshold", freezePosition, seekTo, BUFFER_DISCONTINUITY_THRESHOLD);
+          src_log.warn("Init: discontinuity encountered inferior to the threshold", positionBlockedAt, seekTo, BUFFER_DISCONTINUITY_THRESHOLD);
           _this2._playbackObserver.setCurrentTime(seekTo);
-          _this2.trigger("warning", generateDiscontinuityError(freezePosition, seekTo));
+          _this2.trigger("warning", generateDiscontinuityError(positionBlockedAt, seekTo));
           return;
         }
       }
@@ -24158,11 +24378,11 @@ var RebufferingController = /*#__PURE__*/function (_EventEmitter) {
       //                                                next period
       for (var i = _this2._manifest.periods.length - 2; i >= 0; i--) {
         var period = _this2._manifest.periods[i];
-        if (period.end !== undefined && period.end <= freezePosition) {
-          if (_this2._manifest.periods[i + 1].start > freezePosition && _this2._manifest.periods[i + 1].start > _this2._playbackObserver.getCurrentTime()) {
+        if (period.end !== undefined && period.end <= positionBlockedAt) {
+          if (_this2._manifest.periods[i + 1].start > positionBlockedAt && _this2._manifest.periods[i + 1].start > _this2._playbackObserver.getCurrentTime()) {
             var nextPeriod = _this2._manifest.periods[i + 1];
             _this2._playbackObserver.setCurrentTime(nextPeriod.start);
-            _this2.trigger("warning", generateDiscontinuityError(freezePosition, nextPeriod.start));
+            _this2.trigger("warning", generateDiscontinuityError(positionBlockedAt, nextPeriod.start));
             return;
           }
           break;
@@ -24204,10 +24424,10 @@ var RebufferingController = /*#__PURE__*/function (_EventEmitter) {
     if (!observation.rebuffering || observation.paused || this._speed.getValue() <= 0 || bufferType !== "audio" && bufferType !== "video") {
       return;
     }
-    var currPos = observation.position;
-    var rebufferingPos = (_a = observation.rebuffering.position) !== null && _a !== void 0 ? _a : currPos;
+    var loadedPos = observation.position.getWanted();
+    var rebufferingPos = (_a = observation.rebuffering.position) !== null && _a !== void 0 ? _a : loadedPos;
     var lockedPeriodStart = period.start;
-    if (currPos < lockedPeriodStart && Math.abs(rebufferingPos - lockedPeriodStart) < 1) {
+    if (loadedPos < lockedPeriodStart && Math.abs(rebufferingPos - lockedPeriodStart) < 1) {
       src_log.warn("Init: rebuffering because of a future locked stream.\n" + "Trying to unlock by seeking to the next Period");
       this._playbackObserver.setCurrentTime(lockedPeriodStart + 0.001);
     }
@@ -24240,7 +24460,6 @@ var RebufferingController = /*#__PURE__*/function (_EventEmitter) {
    * right handling steps.
    */;
   _proto._checkDecipherabilityFreeze = function _checkDecipherabilityFreeze(observation) {
-    // XXX TODO allow this in in-worker configuration
     var readyState = observation.readyState,
       rebuffering = observation.rebuffering,
       freezing = observation.freezing;
@@ -24360,8 +24579,9 @@ function eventContainsDiscontinuity(evt) {
  * @returns {Array.<Object>}
  */
 function updateDiscontinuitiesStore(discontinuitiesStore, evt, observation) {
+  var gcTime = Math.min(observation.position.getPolled(), observation.position.getWanted());
   // First, perform clean-up of old discontinuities
-  while (discontinuitiesStore.length > 0 && discontinuitiesStore[0].period.end !== undefined && discontinuitiesStore[0].period.end + 10 < observation.position) {
+  while (discontinuitiesStore.length > 0 && discontinuitiesStore[0].period.end !== undefined && discontinuitiesStore[0].period.end + 10 < gcTime) {
     discontinuitiesStore.shift();
   }
   var period = evt.period,
@@ -24687,9 +24907,11 @@ var StreamEventsEmitter = /*#__PURE__*/function (_EventEmitter) {
         clearInterval(intervalId);
       });
       function constructObservation() {
-        var isSeeking = playbackObserver.getReference().getValue().seeking;
+        var lastObservation = playbackObserver.getReference().getValue();
+        var currentTime = mediaElement.currentTime;
+        var isSeeking = lastObservation.seeking !== 0 /* SeekingState.None */;
         return {
-          currentTime: mediaElement.currentTime,
+          currentTime: currentTime,
           isSeeking: isSeeking
         };
       }
@@ -25202,12 +25424,18 @@ var MediaSourceContentInitializer = /*#__PURE__*/function (_ContentInitializer)
     cancelSignal.register(function () {
       segmentBuffersStore.disposeAll();
     });
-    var _performInitialSeekAn = performInitialSeekAndPlay(mediaElement, playbackObserver, initialTime, autoPlay, function (err) {
-        return _this6.trigger("warning", err);
+    var _performInitialSeekAn = performInitialSeekAndPlay({
+        mediaElement: mediaElement,
+        playbackObserver: playbackObserver,
+        startTime: initialTime,
+        mustAutoPlay: autoPlay,
+        onWarning: function onWarning(err) {
+          _this6.trigger("warning", err);
+        },
+        isDirectfile: false
       }, cancelSignal),
       autoPlayResult = _performInitialSeekAn.autoPlayResult,
-      initialPlayPerformed = _performInitialSeekAn.initialPlayPerformed,
-      initialSeekPerformed = _performInitialSeekAn.initialSeekPerformed;
+      initialPlayPerformed = _performInitialSeekAn.initialPlayPerformed;
     if (cancelSignal.isCancelled()) {
       return;
     }
@@ -25234,15 +25462,19 @@ var MediaSourceContentInitializer = /*#__PURE__*/function (_ContentInitializer)
       autoPlay: autoPlay,
       manifest: manifest,
       initialPlayPerformed: initialPlayPerformed,
-      initialSeekPerformed: initialSeekPerformed,
-      speed: speed,
-      startTime: initialTime
+      speed: speed
     }, cancelSignal);
     var rebufferingController = this._createRebufferingController(playbackObserver, manifest, segmentBuffersStore, speed, cancelSignal);
     rebufferingController.addEventListener("needsReload", function () {
+      var position;
+      var lastObservation = playbackObserver.getReference().getValue();
+      if (lastObservation.position.isAwaitingFuturePosition()) {
+        position = lastObservation.position.getWanted();
+      } else {
+        position = playbackObserver.getCurrentTime();
+      }
       // NOTE couldn't both be always calculated at event destination?
       // Maybe there are exceptions?
-      var position = initialSeekPerformed.getValue() ? playbackObserver.getCurrentTime() : initialTime;
       var autoplay = initialPlayPerformed.getValue() ? !playbackObserver.getIsPaused() : autoPlay;
       onReloadOrder({
         position: position,
@@ -25308,10 +25540,10 @@ var MediaSourceContentInitializer = /*#__PURE__*/function (_ContentInitializer)
             if (
             // Data is buffered around the current position
             obs.currentRange !== null ||
-            // Or, for whatever reason, playback is already advancing
-            obs.position > seekedTime + 0.1) {
+            // Or, for whatever reason, we have no buffer but we're already advancing
+            obs.position.getPolled() > seekedTime + 0.1) {
               stopListening();
-              playbackObserver.setCurrentTime(obs.position + 0.001);
+              playbackObserver.setCurrentTime(obs.position.getWanted() + 0.001);
             }
           }, {
             includeLastObservation: false,
@@ -25400,10 +25632,10 @@ var MediaSourceContentInitializer = /*#__PURE__*/function (_ContentInitializer)
           return self.trigger("bitrateEstimateChange", value);
         },
         needsMediaSourceReload: function needsMediaSourceReload(payload) {
-          var _a, _b;
+          var _a;
           var lastObservation = streamObserver.getReference().getValue();
-          var currentPosition = (_a = lastObservation.position.pending) !== null && _a !== void 0 ? _a : streamObserver.getCurrentTime();
-          var isPaused = (_b = lastObservation.paused.pending) !== null && _b !== void 0 ? _b : streamObserver.getIsPaused();
+          var currentPosition = lastObservation.position.isAwaitingFuturePosition() ? lastObservation.position.getWanted() : streamObserver.getCurrentTime();
+          var isPaused = (_a = lastObservation.paused.pending) !== null && _a !== void 0 ? _a : streamObserver.getIsPaused();
           var position = currentPosition + payload.timeOffset;
           if (payload.minimumPosition !== undefined) {
             position = Math.max(payload.minimumPosition, position);
@@ -25417,19 +25649,19 @@ var MediaSourceContentInitializer = /*#__PURE__*/function (_ContentInitializer)
           });
         },
         needsDecipherabilityFlush: function needsDecipherabilityFlush() {
-          var _a, _b, _c;
+          var _a;
           var keySystem = get_key_system_configuration_getKeySystemConfiguration(mediaElement);
           if (shouldReloadMediaSourceOnDecipherabilityUpdate(keySystem === null || keySystem === void 0 ? void 0 : keySystem[0])) {
             var lastObservation = streamObserver.getReference().getValue();
-            var position = (_a = lastObservation.position.pending) !== null && _a !== void 0 ? _a : streamObserver.getCurrentTime();
-            var isPaused = (_b = lastObservation.paused.pending) !== null && _b !== void 0 ? _b : streamObserver.getIsPaused();
+            var position = lastObservation.position.isAwaitingFuturePosition() ? lastObservation.position.getWanted() : streamObserver.getCurrentTime();
+            var isPaused = (_a = lastObservation.paused.pending) !== null && _a !== void 0 ? _a : streamObserver.getIsPaused();
             onReloadOrder({
               position: position,
               autoPlay: !isPaused
             });
           } else {
             var _lastObservation = streamObserver.getReference().getValue();
-            var _position = (_c = _lastObservation.position.pending) !== null && _c !== void 0 ? _c : streamObserver.getCurrentTime();
+            var _position = _lastObservation.position.isAwaitingFuturePosition() ? _lastObservation.position.getWanted() : streamObserver.getCurrentTime();
             // simple seek close to the current position
             // to flush the buffers
             if (_position + 0.001 < _lastObservation.duration) {
@@ -25491,8 +25723,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) {
@@ -25509,8 +25741,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;
   }
   /**
@@ -27117,7 +27349,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}
  */
@@ -27162,55 +27394,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
@@ -27266,7 +27449,6 @@ function replaceSegmentSmoothTokens(url, time) {
 
 
 
-
 /**
  * @param {Number} start
  * @param {Number} up
@@ -27536,7 +27718,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();
@@ -27574,7 +27756,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
@@ -27607,9 +27805,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
@@ -27617,8 +27815,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}
@@ -27633,8 +27831,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);
@@ -28684,7 +28882,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,
@@ -28692,7 +28891,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;
@@ -28706,9 +28906,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");
@@ -28727,7 +28937,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);
@@ -28738,12 +28948,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();
@@ -28758,7 +28975,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();
@@ -28776,7 +28993,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({
@@ -28790,7 +29007,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));
         }
       }
     };
@@ -28802,6 +29019,9 @@ function request(options) {
       if (timeoutId !== undefined) {
         clearTimeout(timeoutId);
       }
+      if (connectionTimeoutId !== undefined) {
+        clearTimeout(connectionTimeoutId);
+      }
       if (deregisterCancellationListener !== null) {
         deregisterCancellationListener();
       }
@@ -29078,6 +29298,7 @@ function generateRegularManifestLoader(preferredType) {
           url: url,
           responseType: "arraybuffer",
           timeout: loaderOptions.timeout,
+          connectionTimeout: loaderOptions.connectionTimeout,
           cancelSignal: cancelSignal
         });
       case "text":
@@ -29085,6 +29306,7 @@ function generateRegularManifestLoader(preferredType) {
           url: url,
           responseType: "text",
           timeout: loaderOptions.timeout,
+          connectionTimeout: loaderOptions.connectionTimeout,
           cancelSignal: cancelSignal
         });
       case "document":
@@ -29092,6 +29314,7 @@ function generateRegularManifestLoader(preferredType) {
           url: url,
           responseType: "document",
           timeout: loaderOptions.timeout,
+          connectionTimeout: loaderOptions.connectionTimeout,
           cancelSignal: cancelSignal
         });
       default:
@@ -30567,6 +30790,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) {
@@ -30942,6 +31166,7 @@ function constructSegmentUrl(wantedCdn, segment) {
           url: url,
           responseType: "text",
           timeout: loaderOptions.timeout,
+          connectionTimeout: loaderOptions.connectionTimeout,
           cancelSignal: cancelSignal,
           onProgress: callbacks.onProgress
         }).then(function (data) {
@@ -30955,6 +31180,7 @@ function constructSegmentUrl(wantedCdn, segment) {
           url: url,
           responseType: "arraybuffer",
           timeout: loaderOptions.timeout,
+          connectionTimeout: loaderOptions.connectionTimeout,
           cancelSignal: cancelSignal,
           onProgress: callbacks.onProgress
         }).then(function (data) {
@@ -31494,6 +31720,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
@@ -31700,115 +32055,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); }
@@ -32240,13 +32486,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,
@@ -32260,7 +32510,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;
@@ -32393,6 +32649,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;
@@ -32421,7 +32678,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.
@@ -32505,8 +32762,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.
@@ -32762,8 +33019,8 @@ var ListRepresentationIndex = /*#__PURE__*/function () {
   /**
    * @returns {Boolean}
    */;
-  _proto.isFinished = function isFinished() {
-    return true;
+  _proto.isStillAwaitingFutureSegments = function isStillAwaitingFutureSegments() {
+    return false;
   }
   /**
    * @returns {Boolean}
@@ -33209,9 +33466,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
@@ -33223,6 +33484,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,
@@ -33249,8 +33511,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 : {
@@ -33300,7 +33579,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.
@@ -33332,12 +33611,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
@@ -33345,11 +33631,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:
@@ -33363,34 +33658,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
@@ -33408,11 +33725,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:
@@ -33476,6 +33791,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;
@@ -33484,32 +33801,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}
@@ -33543,7 +33894,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
     }
@@ -33555,12 +33906,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.
@@ -33649,6 +33994,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
@@ -33878,13 +34330,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.
@@ -33927,30 +34388,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}
@@ -33988,6 +34449,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
     }
@@ -33996,8 +34458,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;
@@ -34006,7 +34468,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;
     }
@@ -34021,7 +34483,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,
@@ -34029,34 +34491,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;
@@ -34128,7 +34590,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;
@@ -34142,7 +34603,7 @@ function parseRepresentationIndex(representation, context) {
     });
   };
   var reprIndexCtxt = {
-    availabilityTimeComplete: true,
+    availabilityTimeComplete: undefined,
     availabilityTimeOffset: availabilityTimeOffset,
     unsafelyBaseOnPreviousRepresentation: unsafelyBaseOnPreviousRepresentation,
     isEMSGWhitelisted: isEMSGWhitelisted,
@@ -34153,8 +34614,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) {
@@ -34170,8 +34630,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;
@@ -34337,7 +34798,7 @@ 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;
@@ -34353,7 +34814,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,
@@ -34671,7 +35135,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: [],
@@ -34693,14 +35157,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 = [];
@@ -34722,13 +35189,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;
@@ -34775,7 +35241,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,
@@ -34909,8 +35375,8 @@ function parse_periods_arrayLikeToArray(arr, len) { if (len == null || len > arr
 
 
 
-// eslint-disable-next-line max-len
 
+// eslint-disable-next-line max-len
 
 
 
@@ -34923,19 +35389,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
@@ -34950,7 +35412,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 {
@@ -34964,8 +35426,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 = {
@@ -34980,11 +35442,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,
@@ -35059,7 +35520,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;
@@ -35091,7 +35552,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;
@@ -35105,12 +35566,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;
@@ -35208,6 +35669,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
@@ -35330,12 +35792,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,
@@ -35377,29 +35847,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,
@@ -35408,8 +35881,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:
@@ -37562,15 +38037,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) {
@@ -37764,7 +38242,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;
   /**
@@ -37778,13 +38257,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();
@@ -37797,8 +38289,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);
@@ -37845,9 +38337,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;
@@ -37859,9 +38354,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();
           }
@@ -37874,8 +38369,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;
@@ -38068,6 +38566,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) {
@@ -38085,6 +38584,7 @@ function initSegmentLoader(url, segment, options, cancelSignal, callbacks) {
       },
       responseType: "arraybuffer",
       timeout: options.timeout,
+      connectionTimeout: options.connectionTimeout,
       cancelSignal: cancelSignal,
       onProgress: callbacks.onProgress
     }).then(function (data) {
@@ -38103,6 +38603,7 @@ function initSegmentLoader(url, segment, options, cancelSignal, callbacks) {
       },
       responseType: "arraybuffer",
       timeout: options.timeout,
+      connectionTimeout: options.connectionTimeout,
       cancelSignal: cancelSignal,
       onProgress: callbacks.onProgress
     }).then(function (data) {
@@ -38119,6 +38620,7 @@ function initSegmentLoader(url, segment, options, cancelSignal, callbacks) {
     },
     responseType: "arraybuffer",
     timeout: options.timeout,
+    connectionTimeout: options.connectionTimeout,
     cancelSignal: cancelSignal,
     onProgress: callbacks.onProgress
   });
@@ -38129,6 +38631,7 @@ function initSegmentLoader(url, segment, options, cancelSignal, callbacks) {
     },
     responseType: "arraybuffer",
     timeout: options.timeout,
+    connectionTimeout: options.connectionTimeout,
     cancelSignal: cancelSignal,
     onProgress: callbacks.onProgress
   });
@@ -38342,6 +38845,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) {
@@ -39232,6 +39736,7 @@ function generateTextTrackLoader(_ref) {
           Range: byteRange(range)
         } : null,
         timeout: options.timeout,
+        connectionTimeout: options.connectionTimeout,
         onProgress: callbacks.onProgress,
         cancelSignal: cancelSignal
       }).then(function (data) {
@@ -39248,6 +39753,7 @@ function generateTextTrackLoader(_ref) {
         Range: byteRange(range)
       } : null,
       timeout: options.timeout,
+      connectionTimeout: options.connectionTimeout,
       onProgress: callbacks.onProgress,
       cancelSignal: cancelSignal
     }).then(function (data) {
@@ -40445,6 +40951,7 @@ function disableVideoTracks(videoTracks) {
 
 
 
+
 /**
  * `ContentIntializer` which will load contents by putting their URL in the
  * `src` attribute of the given HTMLMediaElement.
@@ -40600,8 +41107,15 @@ var DirectFileContentInitializer = /*#__PURE__*/function (_ContentInitializer) {
       src_log.debug("Init: Initial time calculated:", initTime);
       return initTime;
     };
-    performInitialSeekAndPlay(mediaElement, playbackObserver, initialTime, autoPlay, function (err) {
-      return _this3.trigger("warning", err);
+    performInitialSeekAndPlay({
+      mediaElement: mediaElement,
+      playbackObserver: playbackObserver,
+      startTime: initialTime,
+      mustAutoPlay: autoPlay,
+      onWarning: function onWarning(err) {
+        return _this3.trigger("warning", err);
+      },
+      isDirectfile: true
     }, cancelSignal).autoPlayResult.then(function () {
       return getLoadedReference(playbackObserver, mediaElement, true, cancelSignal).onUpdate(function (isLoaded, stopListening) {
         if (isLoaded) {
@@ -40630,10 +41144,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;
@@ -40641,13 +41155,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;
@@ -44604,12 +45129,9 @@ var serverCertificateHashesMap = new WeakMap();
  * @returns {Object|null}
  */
 function createPersistentSessionsStorage(keySystemOptions) {
-  if (is_null_or_undefined_isNullOrUndefined(keySystemOptions.persistentLicenseConfig)) {
-    return null;
-  }
   var persistentLicenseConfig = keySystemOptions.persistentLicenseConfig;
-  if (persistentLicenseConfig == null) {
-    throw new EncryptedMediaError("INVALID_KEY_SYSTEM", "No `persistentLicenseConfig` found for " + "persistent license.");
+  if (is_null_or_undefined_isNullOrUndefined(persistentLicenseConfig)) {
+    return null;
   }
   src_log.debug("DRM: Set the given license storage");
   return new PersistentSessionsStore(persistentLicenseConfig);
@@ -47138,7 +47660,7 @@ var NativeTextSegmentBuffer = /*#__PURE__*/function (_SegmentBuffer) {
       }
       this._buffered.insert(start, end);
       if (infos.inventoryInfos !== null) {
-        this._segmentInventory.insertChunk(infos.inventoryInfos);
+        this._segmentInventory.insertChunk(infos.inventoryInfos, true);
       }
     } catch (err) {
       return Promise.reject(err);
@@ -50301,7 +50823,7 @@ var HTMLTextSegmentBuffer = /*#__PURE__*/function (_SegmentBuffer) {
       return;
     }
     if (infos.inventoryInfos !== null) {
-      this._segmentInventory.insertChunk(infos.inventoryInfos);
+      this._segmentInventory.insertChunk(infos.inventoryInfos, true);
     }
     this._buffer.insert(cues, start, end);
     this._buffered.insert(start, end);
@@ -50714,10 +51236,11 @@ function applyFontSize(element, fontSize) {
  */
 function applyLineHeight(element, lineHeight) {
   var trimmedLineHeight = lineHeight.trim();
+  var splittedLineHeight = trimmedLineHeight.split(" ");
   if (trimmedLineHeight === "auto") {
     return;
   }
-  var firstLineHeight = REGXP_LENGTH.exec(trimmedLineHeight[0]);
+  var firstLineHeight = REGXP_LENGTH.exec(splittedLineHeight[0]);
   if (firstLineHeight === null) {
     return;
   }