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

package/dist/rx-player.js

@@ -665,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.
@@ -730,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
@@ -5264,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
@@ -5301,6 +5331,7 @@ function getMonotonicTimeStamp() {
 
 
 
+
 /**
  * HTMLMediaElement Events for which playback observations are calculated and
  * emitted.
@@ -5332,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
@@ -5388,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`.
@@ -5454,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
@@ -5461,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 () {
@@ -5531,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
@@ -5559,7 +5712,6 @@ var PlaybackObserver = /*#__PURE__*/function () {
  * @param {Boolean} lowLatencyMode
  * @returns {Number}
  */
-
 function getRebufferingEndGap(rebufferingStatus, lowLatencyMode) {
   if (rebufferingStatus === null) {
     return 0;
@@ -5596,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,
@@ -5634,8 +5785,7 @@ function getMediaInfos(mediaElement, event, withMediaSource) {
     paused: paused,
     playbackRate: playbackRate,
     readyState: readyState,
-    seeking: seeking,
-    event: event
+    seeking: seeking
   };
 }
 /**
@@ -5647,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,
@@ -5703,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;
     }
   }
@@ -5745,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;
 }
@@ -5860,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
 
 
@@ -7078,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()) {
@@ -7303,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.2023120600";
+    _this.version = /* PLAYER_VERSION */"4.0.0-dev.2023121900";
     _this.log = src_log;
     _this.state = "STOPPED";
     _this.videoElement = videoElement;
@@ -7730,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;
       }
     };
@@ -9349,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);
@@ -9539,7 +9710,7 @@ var Player = /*#__PURE__*/function (_EventEmitter) {
   }]);
   return Player;
 }(EventEmitter);
-Player.version = /* PLAYER_VERSION */"4.0.0-dev.2023120600";
+Player.version = /* PLAYER_VERSION */"4.0.0-dev.2023121900";
 /* harmony default export */ var public_api = (Player);
 ;// CONCATENATED MODULE: ./src/core/api/index.ts
 /**
@@ -10063,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
@@ -10126,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;
@@ -10207,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;
@@ -11213,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;
@@ -11307,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) {
@@ -12393,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,
@@ -15886,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);
           }
         }
@@ -15939,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);
         }
       }
@@ -15955,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,
@@ -15973,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,
@@ -16169,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.
@@ -16322,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;
@@ -16337,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);
         }
@@ -16383,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,
@@ -16401,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,
@@ -16951,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);
     }
   }
   /**
@@ -17002,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:
@@ -17834,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,
@@ -19277,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;
@@ -19461,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:
@@ -19490,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);
@@ -19896,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;
@@ -19913,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)
@@ -19966,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,
@@ -20234,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";
@@ -20282,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
@@ -20912,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",
@@ -20967,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";
@@ -21066,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>}
@@ -21184,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:
@@ -21309,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();
         }
@@ -21525,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
       });
@@ -21561,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;
@@ -21569,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: []
@@ -21744,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,
@@ -21760,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);
     };
@@ -21799,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;
       }
@@ -21818,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;
@@ -21990,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;
                 }
@@ -22007,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."));
@@ -22069,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,
@@ -22223,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.
@@ -22364,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);
@@ -22981,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);
@@ -23002,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.
@@ -23013,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,
@@ -23380,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
 /**
@@ -23971,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."); }
@@ -24028,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.
@@ -24069,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,
@@ -24109,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();
@@ -24150,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";
           }
@@ -24163,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);
@@ -24190,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
       //
@@ -24205,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;
         }
       }
@@ -24219,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;
@@ -24265,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);
     }
@@ -24301,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;
@@ -24421,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,
@@ -24748,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
         };
       }
@@ -25263,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;
     }
@@ -25295,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,
@@ -25370,9 +25541,9 @@ var MediaSourceContentInitializer = /*#__PURE__*/function (_ContentInitializer)
             // Data is buffered around the current position
             obs.currentRange !== null ||
             // Or, for whatever reason, we have no buffer but we're already advancing
-            obs.position > seekedTime + 0.1) {
+            obs.position.getPolled() > seekedTime + 0.1) {
               stopListening();
-              playbackObserver.setCurrentTime(obs.position + 0.001);
+              playbackObserver.setCurrentTime(obs.position.getWanted() + 0.001);
             }
           }, {
             includeLastObservation: false,
@@ -25461,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);
@@ -25478,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) {
@@ -40936,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) {
@@ -44951,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);
@@ -47485,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);
@@ -50648,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);
@@ -51061,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;
   }