rx-player 3.31.0-dev.2023052200 → 3.31.1-dev.2023062700

package/CHANGELOG.md

@@ -1,9 +1,19 @@
 # Changelog
 
-## v3.31.0-dev.2023052200 (2023-05-22)
+## v3.31.1-dev.2023062700 (2023-06-27)
+
+### Other improvements
+
+  - Do not load the last text segment if the current position goes after it as it is unnecessary [#1256]
+  - Set a better error message for when no `keySystems` option is set when playing an encrypted content
+
+
+## v3.31.0 (2023-06-14)
 
 ### Features
 
+  - Add `isContentLoaded`, `isBuffering`, `isPaused`, and `getLastStoredContentPosition` methods [#1248]
+  - Add `play` and `paused` events [#1253]
   - Add `trackInfo` property to some `MediaError` to expose information on the track that caused the error [#1241]
 
 ### Bug fixes
@@ -12,13 +22,11 @@
   - Return actual ending duration through the `getVideoDuration` method when playing dynamic contents whose future end is already known [#1235]
   - DASH/WASM: actually reject the `DASH_WASM.initialize`'s Promise if it fails [#1238]
   - On the PlayStation 5, set `Infinity` MediaSource duration for live contents to prevent playback issues [#1250]
-  - DASH/WASM: actually reject the DASH_WASM.initialize's Promise if it fails [#1238]
 
 ### Other improvements
 
   - adaptive: Perform various adaptive tweaks to avoid switching too much between qualities in some conditions [#1237]
   - Directfile: Detect "forced" subtitles on Safari when playing directfile contents (such as HLS) [#1239]
-  - DRM: Reload when playback is unexpectedly frozen with encrypted but only decipherable data in the buffer [#1236]
   - Improve `"direct"` `audioTrackSwitchingMode` compatibility by re-seeking [#1246]
   - The `DEBUG_ELEMENT` feature now uses the `monospace` fallback font as a default for a better rendering on apple devices
   - doc: externalize documentation-generator code

package/VERSION

@@ -1 +1 @@
-3.31.0-dev.2023052200
+3.31.1-dev.2023062700

package/dist/_esm5.processed/core/api/public_api.d.ts

@@ -105,6 +105,10 @@ declare class Player extends EventEmitter<IPublicAPIEvent> {
      * It should refer to the last content being played.
      */
     private _priv_reloadingMetadata;
+    /**
+     * Store last value of autoPlay, from the last load or reload.
+     */
+    private _priv_lastAutoPlay;
     /** All possible Error types emitted by the RxPlayer. */
     static get ErrorTypes(): Record<IErrorType, IErrorType>;
     /** All possible Error codes emitted by the RxPlayer. */
@@ -217,6 +221,26 @@ declare class Player extends EventEmitter<IPublicAPIEvent> {
      * @returns {string} - The current Player's state
      */
     getPlayerState(): string;
+    /**
+     * Returns true if a content is loaded.
+     * @returns {Boolean} - `true` if a content is loaded, `false` otherwise.
+     */
+    isContentLoaded(): boolean;
+    /**
+     * Returns true if the player is buffering.
+     * @returns {Boolean} - `true` if the player is buffering, `false` otherwise.
+     */
+    isBuffering(): boolean;
+    /**
+     * Returns the play/pause status of the player :
+     *   - when `LOADING` or `RELOADING`, returns the scheduled play/pause condition
+     *     for when loading is over,
+     *   - in other states, returns the `<video>` element .paused value,
+     *   - if the player is disposed, returns `true`.
+     * @returns {Boolean} - `true` if the player is paused or will be after loading,
+     * `false` otherwise.
+     */
+    isPaused(): boolean;
     /**
      * Returns true if both:
      *   - a content is loaded
@@ -303,6 +327,12 @@ declare class Player extends EventEmitter<IPublicAPIEvent> {
      * @returns {Number}
      */
     getPosition(): number;
+    /**
+     * Returns the last stored content position, in seconds.
+     *
+     * @returns {number|undefined}
+     */
+    getLastStoredContentPosition(): number | undefined;
     /**
      * Returns the current playback rate at which the video plays.
      * @returns {Number}
@@ -832,6 +862,8 @@ interface IPublicAPIEvent {
     availableTextTracksChange: IAvailableTextTrack[];
     availableVideoTracksChange: IAvailableVideoTrack[];
     decipherabilityUpdate: IDecipherabilityUpdateContent[];
+    play: null;
+    pause: null;
     seeking: null;
     seeked: null;
     streamEvent: IStreamEvent;

package/dist/_esm5.processed/core/api/public_api.js

@@ -51,6 +51,7 @@ import { ErrorCodes, ErrorTypes, formatError, MediaError, } from "../../errors";
 import features from "../../features";
 import log from "../../log";
 import areArraysOfNumbersEqual from "../../utils/are_arrays_of_numbers_equal";
+import arrayIncludes from "../../utils/array_includes";
 import assert from "../../utils/assert";
 import EventEmitter from "../../utils/event_emitter";
 import idGenerator from "../../utils/id_generator";
@@ -65,7 +66,7 @@ import MediaSourceContentInitializer from "../init/media_source_content_initiali
 import { checkReloadOptions, parseConstructorOptions, parseLoadVideoOptions, } from "./option_utils";
 import PlaybackObserver from "./playback_observer";
 import TrackChoiceManager from "./tracks_management/track_choice_manager";
-import { constructPlayerStateReference, emitSeekEvents, isLoadedState, } from "./utils";
+import { constructPlayerStateReference, emitPlayPauseEvents, emitSeekEvents, isLoadedState, } from "./utils";
 /* eslint-disable @typescript-eslint/naming-convention */
 var generateContentId = idGenerator();
 var getPageActivityRef = events.getPageActivityRef, getPictureOnPictureStateRef = events.getPictureOnPictureStateRef, getVideoVisibilityRef = events.getVideoVisibilityRef, getVideoWidthRef = events.getVideoWidthRef, onFullscreenChange = events.onFullscreenChange, onTextTrackAdded = events.onTextTrackAdded, onTextTrackRemoved = events.onTextTrackRemoved;
@@ -89,7 +90,7 @@ var Player = /** @class */ (function (_super) {
         // 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 */ "3.31.0-dev.2023052200";
+        _this.version = /* PLAYER_VERSION */ "3.31.1-dev.2023062700";
         _this.log = log;
         _this.state = "STOPPED";
         _this.videoElement = videoElement;
@@ -172,6 +173,7 @@ var Player = /** @class */ (function (_super) {
         _this._priv_preferredTextTracks = preferredTextTracks;
         _this._priv_preferredVideoTracks = preferredVideoTracks;
         _this._priv_reloadingMetadata = {};
+        _this._priv_lastAutoPlay = false;
         return _this;
     }
     Object.defineProperty(Player, "ErrorTypes", {
@@ -269,6 +271,7 @@ var Player = /** @class */ (function (_super) {
         log.info("API: Calling loadvideo", options.url, options.transport);
         this._priv_reloadingMetadata = { options: options };
         this._priv_initializeContentPlayback(options);
+        this._priv_lastAutoPlay = options.autoPlay;
     };
     /**
      * Reload the last loaded content.
@@ -432,6 +435,9 @@ var Player = /** @class */ (function (_super) {
                 this._priv_currentError = null;
                 throw new Error("DirectFile feature not activated in your build.");
             }
+            else if (isNullOrUndefined(url)) {
+                throw new Error("No URL for a DirectFile content");
+            }
             mediaElementTrackChoiceManager =
                 this._priv_initializeMediaElementTrackChoiceManager(defaultAudioTrack, defaultTextTrack, currentContentCanceller.signal);
             if (currentContentCanceller.isUsed()) {
@@ -485,11 +491,12 @@ var Player = /** @class */ (function (_super) {
             log.warn("API: Sending warning:", formattedError);
             _this.trigger("warning", formattedError);
         });
-        initializer.addEventListener("reloadingMediaSource", function () {
+        initializer.addEventListener("reloadingMediaSource", function (payload) {
             contentInfos.segmentBuffersStore = null;
             if (contentInfos.trackChoiceManager !== null) {
                 contentInfos.trackChoiceManager.resetPeriods();
             }
+            _this._priv_lastAutoPlay = payload.autoPlay;
         });
         initializer.addEventListener("inbandEvents", function (inbandEvents) {
             return _this.trigger("inbandEvents", inbandEvents);
@@ -591,6 +598,48 @@ var Player = /** @class */ (function (_super) {
                     break;
             }
         };
+        /**
+         * `TaskCanceller` allowing to stop emitting `"play"` and `"pause"`
+         * events.
+         * `null` when such events are not emitted currently.
+         */
+        var playPauseEventsCanceller = null;
+        /**
+         * Callback emitting `"play"` and `"pause`" events once the content is
+         * loaded, starting from the state indicated in argument.
+         * @param {boolean} willAutoPlay - If `false`, we're currently paused.
+         */
+        var triggerPlayPauseEventsWhenReady = function (willAutoPlay) {
+            if (playPauseEventsCanceller !== null) {
+                playPauseEventsCanceller.cancel(); // cancel previous logic
+                playPauseEventsCanceller = null;
+            }
+            playerStateRef.onUpdate(function (val, stopListeningToStateUpdates) {
+                if (!isLoadedState(val)) {
+                    return; // content not loaded yet: no event
+                }
+                stopListeningToStateUpdates();
+                if (playPauseEventsCanceller !== null) {
+                    playPauseEventsCanceller.cancel();
+                }
+                playPauseEventsCanceller = new TaskCanceller();
+                playPauseEventsCanceller.linkToSignal(currentContentCanceller.signal);
+                if (willAutoPlay !== !videoElement.paused) {
+                    // paused status is not at the expected value on load: emit event
+                    if (videoElement.paused) {
+                        _this.trigger("pause", null);
+                    }
+                    else {
+                        _this.trigger("play", null);
+                    }
+                }
+                emitPlayPauseEvents(videoElement, function () { return _this.trigger("play", null); }, function () { return _this.trigger("pause", null); }, currentContentCanceller.signal);
+            }, { emitCurrentValue: false, clearSignal: currentContentCanceller.signal });
+        };
+        triggerPlayPauseEventsWhenReady(autoPlay);
+        initializer.addEventListener("reloadingMediaSource", function (payload) {
+            triggerPlayPauseEventsWhenReady(payload.autoPlay);
+        });
         /**
          * `TaskCanceller` allowing to stop emitting `"seeking"` and `"seeked"`
          * events.
@@ -732,6 +781,40 @@ var Player = /** @class */ (function (_super) {
     Player.prototype.getPlayerState = function () {
         return this.state;
     };
+    /**
+     * Returns true if a content is loaded.
+     * @returns {Boolean} - `true` if a content is loaded, `false` otherwise.
+     */
+    Player.prototype.isContentLoaded = function () {
+        return !arrayIncludes(["LOADING", "RELOADING", "STOPPED"], this.state);
+    };
+    /**
+     * Returns true if the player is buffering.
+     * @returns {Boolean} - `true` if the player is buffering, `false` otherwise.
+     */
+    Player.prototype.isBuffering = function () {
+        return arrayIncludes(["BUFFERING", "SEEKING", "LOADING", "RELOADING"], this.state);
+    };
+    /**
+     * Returns the play/pause status of the player :
+     *   - when `LOADING` or `RELOADING`, returns the scheduled play/pause condition
+     *     for when loading is over,
+     *   - in other states, returns the `<video>` element .paused value,
+     *   - if the player is disposed, returns `true`.
+     * @returns {Boolean} - `true` if the player is paused or will be after loading,
+     * `false` otherwise.
+     */
+    Player.prototype.isPaused = function () {
+        if (this.videoElement) {
+            if (arrayIncludes(["LOADING", "RELOADING"], this.state)) {
+                return !this._priv_lastAutoPlay;
+            }
+            else {
+                return this.videoElement.paused;
+            }
+        }
+        return true;
+    };
     /**
      * Returns true if both:
      *   - a content is loaded
@@ -897,6 +980,14 @@ var Player = /** @class */ (function (_super) {
         }
         return this.videoElement.currentTime;
     };
+    /**
+     * Returns the last stored content position, in seconds.
+     *
+     * @returns {number|undefined}
+     */
+    Player.prototype.getLastStoredContentPosition = function () {
+        return this._priv_reloadingMetadata.reloadPosition;
+    };
     /**
      * Returns the current playback rate at which the video plays.
      * @returns {Number}
@@ -2340,5 +2431,5 @@ var Player = /** @class */ (function (_super) {
     };
     return Player;
 }(EventEmitter));
-Player.version = /* PLAYER_VERSION */ "3.31.0-dev.2023052200";
+Player.version = /* PLAYER_VERSION */ "3.31.1-dev.2023062700";
 export default Player;

package/dist/_esm5.processed/core/api/utils.d.ts

@@ -30,6 +30,16 @@ import { IPlaybackObservation, IReadOnlyPlaybackObserver } from "./playback_obse
  * remove all listeners this function has registered.
  */
 export declare function emitSeekEvents(mediaElement: HTMLMediaElement | null, playbackObserver: IReadOnlyPlaybackObserver<IPlaybackObservation>, onSeeking: () => void, onSeeked: () => void, cancelSignal: CancellationSignal): void;
+/**
+ * @param {HTMLMediaElement} mediaElement
+ * @param {function} onPlay - Callback called when a play operation has started
+ * on `mediaElement`.
+ * @param {function} onPause - Callback called when a pause operation has
+ * started on `mediaElement`.
+ * @param {Object} cancelSignal - When triggered, stop calling callbacks and
+ * remove all listeners this function has registered.
+ */
+export declare function emitPlayPauseEvents(mediaElement: HTMLMediaElement | null, onPlay: () => void, onPause: () => void, cancelSignal: CancellationSignal): void;
 /** Player state dictionnary. */
 export declare const enum PLAYER_STATES {
     STOPPED = "STOPPED",

package/dist/_esm5.processed/core/api/utils.js

@@ -49,6 +49,26 @@ export function emitSeekEvents(mediaElement, playbackObserver, onSeeking, onSeek
         }
     }, { includeLastObservation: true, clearSignal: cancelSignal });
 }
+/**
+ * @param {HTMLMediaElement} mediaElement
+ * @param {function} onPlay - Callback called when a play operation has started
+ * on `mediaElement`.
+ * @param {function} onPause - Callback called when a pause operation has
+ * started on `mediaElement`.
+ * @param {Object} cancelSignal - When triggered, stop calling callbacks and
+ * remove all listeners this function has registered.
+ */
+export function emitPlayPauseEvents(mediaElement, onPlay, onPause, cancelSignal) {
+    if (cancelSignal.isCancelled() || mediaElement === null) {
+        return;
+    }
+    mediaElement.addEventListener("play", onPlay);
+    mediaElement.addEventListener("pause", onPause);
+    cancelSignal.register(function () {
+        mediaElement.removeEventListener("play", onPlay);
+        mediaElement.removeEventListener("pause", onPause);
+    });
+}
 export function constructPlayerStateReference(initializer, mediaElement, playbackObserver, cancelSignal) {
     var playerStateRef = createSharedReference("LOADING" /* PLAYER_STATES.LOADING */, cancelSignal);
     initializer.addEventListener("loaded", function () {

package/dist/_esm5.processed/core/decrypt/session_events_listener.js

@@ -130,7 +130,13 @@ export default function SessionEventsListener(session, keySystemOptions, keySyst
                 log.info("DRM: No license given, skipping session.update");
             }
             else {
-                return updateSessionWithMessage(session, licenseObject);
+                try {
+                    return updateSessionWithMessage(session, licenseObject);
+                }
+                catch (err) {
+                    manualCanceller.cancel();
+                    callbacks.onError(err);
+                }
             }
         })
             .catch(function (err) {

package/dist/_esm5.processed/core/init/directfile_content_initializer.d.ts

@@ -18,21 +18,80 @@ import { IReadOnlySharedReference } from "../../utils/reference";
 import { PlaybackObserver } from "../api";
 import { ContentInitializer } from "./types";
 import { IInitialTimeOptions } from "./utils/get_initial_time";
+/**
+ * `ContentIntializer` which will load contents by putting their URL in the
+ * `src` attribute of the given HTMLMediaElement.
+ *
+ * Because such contents are mainly loaded by the browser, those (called
+ * "directfile" contents in the RxPlayer) needs a simpler logic in-JS when
+ * compared to a content that relies on the MSE API.
+ *
+ * @class DirectFileContentInitializer
+ */
 export default class DirectFileContentInitializer extends ContentInitializer {
+    /**
+     * Initial options given to the `DirectFileContentInitializer`.
+     */
     private _settings;
+    /**
+     * Allows to abort and clean everything the `DirectFileContentInitializer` is
+     * doing.
+     */
     private _initCanceller;
+    /**
+     * Creates a new `DirectFileContentInitializer` linked to the given settings.
+     * @param {Object} settings
+     */
     constructor(settings: IDirectFileOptions);
+    /**
+     * "Prepare" content so it can later be played by calling `start`.
+     */
     prepare(): void;
+    /**
+     * Start playback of the content linked to this `DirectFileContentInitializer`
+     * on the given `HTMLMediaElement` and its associated `PlaybackObserver`.
+     * @param {HTMLMediaElement} mediaElement - HTMLMediaElement on which the
+     * content will be played.
+     * @param {Object} playbackObserver - Object regularly emitting playback
+     * information.
+     */
     start(mediaElement: HTMLMediaElement, playbackObserver: PlaybackObserver): void;
+    /**
+     * Update URL this `ContentIntializer` depends on.
+     * @param {Array.<string>|undefined} _urls
+     * @param {boolean} _refreshNow
+     */
     updateContentUrls(_urls: string[] | undefined, _refreshNow: boolean): void;
+    /**
+     * Stop content and free all resources linked to this `ContentIntializer`.
+     */
     dispose(): void;
+    /**
+     * Logic performed when a fatal error was triggered.
+     * @param {*} err - The fatal error in question.
+     */
     private _onFatalError;
+    /**
+     * Perform the initial seek (to begin playback at an initially-calculated
+     * position based on settings) and auto-play if needed when loaded.
+     * @param {HTMLMediaElement} mediaElement
+     * @param {Object} playbackObserver
+     */
     private _seekAndPlay;
 }
+/** Options used by the `DirectFileContentInitializer` */
 export interface IDirectFileOptions {
+    /** If `true` we will play right after the content is considered "loaded". */
     autoPlay: boolean;
+    /**
+     * Encryption-related settings. Can be left as an empty array if the content
+     * isn't encrypted.
+     */
     keySystems: IKeySystemOption[];
+    /** Communicate the playback rate wanted by the user. */
     speed: IReadOnlySharedReference<number>;
+    /** Optional initial position to start at. */
     startAt?: IInitialTimeOptions | undefined;
-    url?: string | undefined;
+    /** URL that should be played. */
+    url: string;
 }

package/dist/_esm5.processed/core/init/directfile_content_initializer.js

@@ -34,6 +34,7 @@ var __extends = (this && this.__extends) || (function () {
  */
 import { clearElementSrc } from "../../compat";
 import log from "../../log";
+import assert from "../../utils/assert";
 import createSharedReference from "../../utils/reference";
 import TaskCanceller from "../../utils/task_canceller";
 import { ContentInitializer } from "./types";
@@ -42,25 +43,51 @@ import performInitialSeekAndPlay from "./utils/initial_seek_and_play";
 import initializeContentDecryption from "./utils/initialize_content_decryption";
 import RebufferingController from "./utils/rebuffering_controller";
 import listenToMediaError from "./utils/throw_on_media_error";
+/**
+ * `ContentIntializer` which will load contents by putting their URL in the
+ * `src` attribute of the given HTMLMediaElement.
+ *
+ * Because such contents are mainly loaded by the browser, those (called
+ * "directfile" contents in the RxPlayer) needs a simpler logic in-JS when
+ * compared to a content that relies on the MSE API.
+ *
+ * @class DirectFileContentInitializer
+ */
 var DirectFileContentInitializer = /** @class */ (function (_super) {
     __extends(DirectFileContentInitializer, _super);
+    /**
+     * Creates a new `DirectFileContentInitializer` linked to the given settings.
+     * @param {Object} settings
+     */
     function DirectFileContentInitializer(settings) {
         var _this = _super.call(this) || this;
         _this._settings = settings;
         _this._initCanceller = new TaskCanceller();
         return _this;
     }
+    /**
+     * "Prepare" content so it can later be played by calling `start`.
+     */
     DirectFileContentInitializer.prototype.prepare = function () {
         return; // Directfile contents do not have any preparation
     };
+    /**
+     * Start playback of the content linked to this `DirectFileContentInitializer`
+     * on the given `HTMLMediaElement` and its associated `PlaybackObserver`.
+     * @param {HTMLMediaElement} mediaElement - HTMLMediaElement on which the
+     * content will be played.
+     * @param {Object} playbackObserver - Object regularly emitting playback
+     * information.
+     */
     DirectFileContentInitializer.prototype.start = function (mediaElement, playbackObserver) {
         var _this = this;
         var cancelSignal = this._initCanceller.signal;
         var _a = this._settings, keySystems = _a.keySystems, speed = _a.speed, url = _a.url;
         clearElementSrc(mediaElement);
-        if (url == null) {
-            throw new Error("No URL for a DirectFile content");
-        }
+        /**
+         * Create dummy encryption data emitter, as those are not sent from the
+         * RxPlayer for directfile contents.
+         */
         var decryptionRef = createSharedReference(null);
         decryptionRef.finish();
         var drmInitRef = initializeContentDecryption(mediaElement, keySystems, decryptionRef, {
@@ -89,7 +116,7 @@ var DirectFileContentInitializer = /** @class */ (function (_super) {
         rebufferingController.start();
         drmInitRef.onUpdate(function (evt, stopListeningToDrmUpdates) {
             if (evt.initializationState.type === "uninitialized") {
-                return;
+                return; // nothing done yet
             }
             stopListeningToDrmUpdates();
             // Start everything! (Just put the URL in the element's src).
@@ -104,26 +131,43 @@ var DirectFileContentInitializer = /** @class */ (function (_super) {
                     if (newDrmStatus.initializationState.type === "initialized") {
                         stopListeningToDrmUpdatesAgain();
                         _this._seekAndPlay(mediaElement, playbackObserver);
-                        return;
                     }
                 }, { emitCurrentValue: true, clearSignal: cancelSignal });
             }
             else {
+                assert(evt.initializationState.type === "initialized");
                 _this._seekAndPlay(mediaElement, playbackObserver);
-                return;
             }
         }, { emitCurrentValue: true, clearSignal: cancelSignal });
     };
+    /**
+     * Update URL this `ContentIntializer` depends on.
+     * @param {Array.<string>|undefined} _urls
+     * @param {boolean} _refreshNow
+     */
     DirectFileContentInitializer.prototype.updateContentUrls = function (_urls, _refreshNow) {
         throw new Error("Cannot update content URL of directfile contents");
     };
+    /**
+     * Stop content and free all resources linked to this `ContentIntializer`.
+     */
     DirectFileContentInitializer.prototype.dispose = function () {
         this._initCanceller.cancel();
     };
+    /**
+     * Logic performed when a fatal error was triggered.
+     * @param {*} err - The fatal error in question.
+     */
     DirectFileContentInitializer.prototype._onFatalError = function (err) {
         this._initCanceller.cancel();
         this.trigger("error", err);
     };
+    /**
+     * Perform the initial seek (to begin playback at an initially-calculated
+     * position based on settings) and auto-play if needed when loaded.
+     * @param {HTMLMediaElement} mediaElement
+     * @param {Object} playbackObserver
+     */
     DirectFileContentInitializer.prototype._seekAndPlay = function (mediaElement, playbackObserver) {
         var _this = this;
         var cancelSignal = this._initCanceller.signal;
@@ -156,7 +200,7 @@ export default DirectFileContentInitializer;
 /**
  * calculate initial time as a position in seconds.
  * @param {HTMLMediaElement} mediaElement
- * @param {Object|undefined} startAt
+ * @param {Object|undefined} [startAt]
  * @returns {number}
  */
 function getDirectFileInitialTime(mediaElement, startAt) {

package/dist/_esm5.processed/core/init/media_source_content_initializer.js

@@ -249,7 +249,7 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
                     if (initCanceller.isUsed()) {
                         return;
                     }
-                    triggerEvent("reloadingMediaSource", null);
+                    triggerEvent("reloadingMediaSource", reloadOrder);
                     if (initCanceller.isUsed()) {
                         return;
                     }

package/dist/_esm5.processed/core/init/types.d.ts

@@ -95,7 +95,15 @@ export interface IContentInitializerEvents {
      * Event sent when we're starting attach a new MediaSource to the media element
      * (after removing the previous one).
      */
-    reloadingMediaSource: null;
+    reloadingMediaSource: {
+        /** The position we're reloading at, in seconds. */
+        position: number;
+        /**
+         * If `true`, we'll play directly after finishing the reloading operation.
+         * If `false`, we'll be paused after it.
+         */
+        autoPlay: boolean;
+    };
     /** Event sent after the player stalled. */
     stalled: IStallingSituation;
     /** Event sent when the player goes out of a stalling situation. */

package/dist/_esm5.processed/core/init/utils/initialize_content_decryption.js

@@ -34,8 +34,8 @@ export default function initializeContentDecryption(mediaElement, keySystems, pr
                 return;
             }
             stopListening();
-            log.error("Init: Encrypted event but EME feature not activated");
-            var err = new EncryptedMediaError("MEDIA_IS_ENCRYPTED_ERROR", "EME feature not activated.");
+            log.error("Init: Encrypted event but no `keySystems` given");
+            var err = new EncryptedMediaError("MEDIA_IS_ENCRYPTED_ERROR", "no `keySystems` given.");
             callbacks.onError(err);
         }, { clearSignal: cancelSignal });
         var ref = createSharedReference({

package/dist/_esm5.processed/core/stream/representation/utils/get_buffer_status.js

@@ -15,7 +15,7 @@
  */
 import config from "../../../../config";
 import isNullOrUndefined from "../../../../utils/is_null_or_undefined";
-import { SegmentBufferOperation, } from "../../../segment_buffers";
+import SegmentBuffersStore, { SegmentBufferOperation, } from "../../../segment_buffers";
 import checkForDiscontinuity from "./check_for_discontinuity";
 import getNeededSegments from "./get_needed_segments";
 import getSegmentPriority from "./get_segment_priority";
@@ -116,6 +116,7 @@ function getRangeOfNeededSegments(content, initialWantedTime, bufferGoal) {
     // avoid ending the last Period - and by extension the content - with a
     // segment which isn't the last one.
     if (!isNullOrUndefined(lastIndexPosition) &&
+        SegmentBuffersStore.isNative(content.adaptation.type) &&
         initialWantedTime >= lastIndexPosition &&
         representationIndex.isInitialized() &&
         representationIndex.isFinished() &&