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

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

@@ -50,6 +50,7 @@ export declare const enum PLAYER_STATES {
     ENDED = "ENDED",
     BUFFERING = "BUFFERING",
     SEEKING = "SEEKING",
+    FREEZING = "FREEZING",
     RELOADING = "RELOADING"
 }
 export declare function constructPlayerStateReference(initializer: ContentInitializer, mediaElement: HTMLMediaElement, playbackObserver: IReadOnlyPlaybackObserver<IPlaybackObservation>, cancelSignal: CancellationSignal): IReadOnlySharedReference<IPlayerState>;

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

@@ -16,6 +16,7 @@
 import config from "../../config";
 import arrayIncludes from "../../utils/array_includes";
 import SharedReference from "../../utils/reference";
+var arr = ["seeking", "ended", "play", "pause"];
 /**
  * @param {HTMLMediaElement} mediaElement
  * @param {Object} playbackObserver - Observes playback conditions on
@@ -82,7 +83,7 @@ export function constructPlayerStateReference(initializer, mediaElement, playbac
             }
         }
         else {
-            playerStateRef.setValueIfChanged(getLoadedContentState(mediaElement, null));
+            updateStateIfLoaded(null);
         }
     }, cancelSignal);
     initializer.addEventListener("reloadingMediaSource", function () {
@@ -97,27 +98,42 @@ export function constructPlayerStateReference(initializer, mediaElement, playbac
     var prevStallReason = null;
     initializer.addEventListener("stalled", function (s) {
         if (s !== prevStallReason) {
-            if (isLoadedState(playerStateRef.getValue())) {
-                playerStateRef.setValueIfChanged(getLoadedContentState(mediaElement, s));
-            }
+            updateStateIfLoaded(s);
             prevStallReason = s;
         }
     }, cancelSignal);
     initializer.addEventListener("unstalled", function () {
         if (prevStallReason !== null) {
-            if (isLoadedState(playerStateRef.getValue())) {
-                playerStateRef.setValueIfChanged(getLoadedContentState(mediaElement, null));
-            }
+            updateStateIfLoaded(null);
             prevStallReason = null;
         }
     }, cancelSignal);
     playbackObserver.listen(function (observation) {
-        if (isLoadedState(playerStateRef.getValue()) &&
-            arrayIncludes(["seeking", "ended", "play", "pause"], observation.event)) {
-            playerStateRef.setValueIfChanged(getLoadedContentState(mediaElement, prevStallReason));
+        var initialState = playerStateRef.getValue();
+        if (isLoadedState(initialState) &&
+            arrayIncludes(arr, observation.event)) {
+            var newState = getLoadedContentState(mediaElement, prevStallReason);
+            window.sendLog("STATE cHAG: " + newState + " " + initialState);
+            // Some safety checks to avoid having nonsense state switches
+            if (newState === "PAUSED" /* PLAYER_STATES.PAUSED */ && initialState === "LOADED" /* PLAYER_STATES.LOADED */) {
+                return;
+            }
+            playerStateRef.setValueIfChanged(newState);
         }
     }, { clearSignal: cancelSignal });
     return playerStateRef;
+    function updateStateIfLoaded(stallRes) {
+        var initialState = playerStateRef.getValue();
+        if (!isLoadedState(initialState)) {
+            return;
+        }
+        var newState = getLoadedContentState(mediaElement, stallRes);
+        // Some safety checks to avoid having nonsense state switches
+        if (initialState === "LOADED" /* PLAYER_STATES.LOADED */ && newState === "PAUSED" /* PLAYER_STATES.PAUSED */) {
+            return;
+        }
+        playerStateRef.setValueIfChanged(newState);
+    }
 }
 /**
  * Get state string for a _loaded_ content.
@@ -144,7 +160,8 @@ export function getLoadedContentState(mediaElement, stalledStatus) {
             return "ENDED" /* PLAYER_STATES.ENDED */;
         }
         return stalledStatus === "seeking" ? "SEEKING" /* PLAYER_STATES.SEEKING */ :
-            "BUFFERING" /* PLAYER_STATES.BUFFERING */;
+            stalledStatus === "freezing" ? "FREEZING" /* PLAYER_STATES.FREEZING */ :
+                "BUFFERING" /* PLAYER_STATES.BUFFERING */;
     }
     return mediaElement.paused ? "PAUSED" /* PLAYER_STATES.PAUSED */ :
         "PLAYING" /* PLAYER_STATES.PLAYING */;

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

@@ -166,8 +166,8 @@ var ContentDecryptor = /** @class */ (function (_super) {
              * MediaKeySessions persisted in older RxPlayer's versions.
              */
             var systemId;
-            if (isNullOrUndefined(options.licenseStorage) ||
-                options.licenseStorage.disableRetroCompatibility === true) {
+            if (isNullOrUndefined(options.persistentLicenseConfig) ||
+                options.persistentLicenseConfig.disableRetroCompatibility === true) {
                 systemId = getDrmSystemId(mediaKeySystemAccess.keySystem);
             }
             _this.systemId = systemId;
@@ -405,7 +405,7 @@ var ContentDecryptor = /** @class */ (function (_super) {
                         // persistent sessions.
                         // Can we find a better strategy?
                         this._lockInitDataQueue();
-                        if (options.persistentLicense !== true) {
+                        if (isNullOrUndefined(options.persistentLicenseConfig)) {
                             wantedSessionType = "temporary";
                         }
                         else if (!canCreatePersistentSession(mediaKeySystemAccess)) {

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

@@ -85,11 +85,12 @@ function checkCachedMediaKeySystemAccess(keySystems, currentKeySystemAccess, cur
         if (ks.type !== currentKeySystemOptions.type) {
             return false;
         }
-        if ((ks.persistentLicense === true || ks.persistentStateRequired === true) &&
+        if ((!isNullOrUndefined(ks.persistentLicenseConfig) ||
+            ks.persistentState === "required") &&
             mksConfiguration.persistentState !== "required") {
             return false;
         }
-        if (ks.distinctiveIdentifierRequired === true &&
+        if (ks.distinctiveIdentifier === "required" &&
             mksConfiguration.distinctiveIdentifier !== "required") {
             return false;
         }
@@ -119,67 +120,26 @@ function findKeySystemCanonicalName(ksType) {
 /**
  * Build configuration for the requestMediaKeySystemAccess EME API, based
  * on the current keySystem object.
- * @param {string|undefined} ksName - Generic name for the key system. e.g.
- * "clearkey", "widevine", "playready". Can be used to make exceptions depending
- * on it.
- * @param {string|undefined} ksType - KeySystem complete type (e.g.
- * "com.widevine.alpha").
- * @param {Object} keySystem
+ * @param {Object} keySystemTypeInfo
  * @returns {Array.<Object>} - Configuration to give to the
  * requestMediaKeySystemAccess API.
  */
-function buildKeySystemConfigurations(ksName, ksType, keySystem) {
+function buildKeySystemConfigurations(keySystemTypeInfo) {
+    var keyName = keySystemTypeInfo.keyName, keyType = keySystemTypeInfo.keyType, keySystem = keySystemTypeInfo.keySystemOptions;
     var sessionTypes = ["temporary"];
     var persistentState = "optional";
     var distinctiveIdentifier = "optional";
-    if (keySystem.persistentLicense === true) {
+    if (!isNullOrUndefined(keySystem.persistentLicenseConfig)) {
         persistentState = "required";
         sessionTypes.push("persistent-license");
     }
-    if (keySystem.persistentStateRequired === true) {
-        persistentState = "required";
-    }
-    if (keySystem.distinctiveIdentifierRequired === true) {
-        distinctiveIdentifier = "required";
-    }
-    var _a = config.getCurrent(), EME_DEFAULT_AUDIO_CODECS = _a.EME_DEFAULT_AUDIO_CODECS, EME_DEFAULT_VIDEO_CODECS = _a.EME_DEFAULT_VIDEO_CODECS, EME_DEFAULT_WIDEVINE_ROBUSTNESSES = _a.EME_DEFAULT_WIDEVINE_ROBUSTNESSES, EME_DEFAULT_PLAYREADY_ROBUSTNESSES = _a.EME_DEFAULT_PLAYREADY_ROBUSTNESSES;
-    // Set robustness, in order of consideration:
-    //   1. the user specified its own robustnesses
-    //   2. a "widevine" key system is used, in that case set the default widevine
-    //      robustnesses as defined in the config
-    //   3. set an undefined robustness
-    var videoRobustnesses;
-    if (!isNullOrUndefined(keySystem.videoRobustnesses)) {
-        videoRobustnesses = keySystem.videoRobustnesses;
-    }
-    else if (ksName === "widevine") {
-        videoRobustnesses = EME_DEFAULT_WIDEVINE_ROBUSTNESSES;
-    }
-    else if (ksType === "com.microsoft.playready.recommendation") {
-        videoRobustnesses = EME_DEFAULT_PLAYREADY_ROBUSTNESSES;
-    }
-    else {
-        videoRobustnesses = [];
-    }
-    var audioRobustnesses;
-    if (!isNullOrUndefined(keySystem.audioRobustnesses)) {
-        audioRobustnesses = keySystem.audioRobustnesses;
-    }
-    else if (ksName === "widevine") {
-        audioRobustnesses = EME_DEFAULT_WIDEVINE_ROBUSTNESSES;
+    if (!isNullOrUndefined(keySystem.persistentState)) {
+        persistentState = keySystem.persistentState;
     }
-    else if (ksType === "com.microsoft.playready.recommendation") {
-        audioRobustnesses = EME_DEFAULT_PLAYREADY_ROBUSTNESSES;
-    }
-    else {
-        audioRobustnesses = [];
-    }
-    if (videoRobustnesses.length === 0) {
-        videoRobustnesses.push(undefined);
-    }
-    if (audioRobustnesses.length === 0) {
-        audioRobustnesses.push(undefined);
+    if (!isNullOrUndefined(keySystem.distinctiveIdentifier)) {
+        distinctiveIdentifier = keySystem.distinctiveIdentifier;
     }
+    var _a = config.getCurrent(), EME_DEFAULT_AUDIO_CODECS = _a.EME_DEFAULT_AUDIO_CODECS, EME_DEFAULT_VIDEO_CODECS = _a.EME_DEFAULT_VIDEO_CODECS, EME_DEFAULT_WIDEVINE_ROBUSTNESSES = _a.EME_DEFAULT_WIDEVINE_ROBUSTNESSES, EME_DEFAULT_PLAYREADY_RECOMMENDATION_ROBUSTNESSES = _a.EME_DEFAULT_PLAYREADY_RECOMMENDATION_ROBUSTNESSES;
     // From the W3 EME spec, we have to provide videoCapabilities and
     // audioCapabilities.
     // These capabilities must specify a codec (even though you can use a
@@ -191,18 +151,69 @@ function buildKeySystemConfigurations(ksName, ksType, keySystem) {
     // More details here:
     // https://storage.googleapis.com/wvdocs/Chrome_EME_Changes_and_Best_Practices.pdf
     // https://www.w3.org/TR/encrypted-media/#get-supported-configuration-and-consent
-    var videoCapabilities = flatMap(videoRobustnesses, function (robustness) {
-        return EME_DEFAULT_VIDEO_CODECS.map(function (contentType) {
-            return robustness === undefined ? { contentType: contentType } :
-                { contentType: contentType, robustness: robustness };
+    var audioCapabilities;
+    var videoCapabilities;
+    var audioCapabilitiesConfig = keySystem.audioCapabilitiesConfig, videoCapabilitiesConfig = keySystem.videoCapabilitiesConfig;
+    if ((audioCapabilitiesConfig === null || audioCapabilitiesConfig === void 0 ? void 0 : audioCapabilitiesConfig.type) === "full") {
+        audioCapabilities = audioCapabilitiesConfig.value;
+    }
+    else {
+        var audioRobustnesses = void 0;
+        if ((audioCapabilitiesConfig === null || audioCapabilitiesConfig === void 0 ? void 0 : audioCapabilitiesConfig.type) === "robustness") {
+            audioRobustnesses = audioCapabilitiesConfig.value;
+        }
+        else if (keyName === "widevine") {
+            audioRobustnesses = EME_DEFAULT_WIDEVINE_ROBUSTNESSES;
+        }
+        else if (keyType === "com.microsoft.playready.recommendation") {
+            audioRobustnesses = EME_DEFAULT_PLAYREADY_RECOMMENDATION_ROBUSTNESSES;
+        }
+        else {
+            audioRobustnesses = [];
+        }
+        if (audioRobustnesses.length === 0) {
+            audioRobustnesses.push(undefined);
+        }
+        var audioCodecs_1 = (audioCapabilitiesConfig === null || audioCapabilitiesConfig === void 0 ? void 0 : audioCapabilitiesConfig.type) === "contentType" ?
+            audioCapabilitiesConfig.value :
+            EME_DEFAULT_AUDIO_CODECS;
+        audioCapabilities = flatMap(audioRobustnesses, function (robustness) {
+            return audioCodecs_1.map(function (contentType) {
+                return robustness !== undefined ? { contentType: contentType, robustness: robustness } :
+                    { contentType: contentType };
+            });
         });
-    });
-    var audioCapabilities = flatMap(audioRobustnesses, function (robustness) {
-        return EME_DEFAULT_AUDIO_CODECS.map(function (contentType) {
-            return robustness === undefined ? { contentType: contentType } :
-                { contentType: contentType, robustness: robustness };
+    }
+    if ((videoCapabilitiesConfig === null || videoCapabilitiesConfig === void 0 ? void 0 : videoCapabilitiesConfig.type) === "full") {
+        videoCapabilities = videoCapabilitiesConfig.value;
+    }
+    else {
+        var videoRobustnesses = void 0;
+        if ((videoCapabilitiesConfig === null || videoCapabilitiesConfig === void 0 ? void 0 : videoCapabilitiesConfig.type) === "robustness") {
+            videoRobustnesses = videoCapabilitiesConfig.value;
+        }
+        else if (keyName === "widevine") {
+            videoRobustnesses = EME_DEFAULT_WIDEVINE_ROBUSTNESSES;
+        }
+        else if (keyType === "com.microsoft.playready.recommendation") {
+            videoRobustnesses = EME_DEFAULT_PLAYREADY_RECOMMENDATION_ROBUSTNESSES;
+        }
+        else {
+            videoRobustnesses = [];
+        }
+        if (videoRobustnesses.length === 0) {
+            videoRobustnesses.push(undefined);
+        }
+        var videoCodecs_1 = (videoCapabilitiesConfig === null || videoCapabilitiesConfig === void 0 ? void 0 : videoCapabilitiesConfig.type) === "contentType" ?
+            videoCapabilitiesConfig.value :
+            EME_DEFAULT_VIDEO_CODECS;
+        videoCapabilities = flatMap(videoRobustnesses, function (robustness) {
+            return videoCodecs_1.map(function (contentType) {
+                return robustness !== undefined ? { contentType: contentType, robustness: robustness } :
+                    { contentType: contentType };
+            });
         });
-    });
+    }
     var wantedMediaKeySystemConfiguration = {
         initDataTypes: ["cenc"],
         videoCapabilities: videoCapabilities,
@@ -291,9 +302,9 @@ export default function getMediaKeySystemAccess(mediaElement, keySystemsConfigs,
      */
     function recursivelyTestKeySystems(index) {
         return __awaiter(this, void 0, void 0, function () {
-            var _a, keyName, keyType, keySystemOptions, keySystemConfigurations, keySystemAccess, _1;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
+            var chosenType, keyType, keySystemOptions, keySystemConfigurations, keySystemAccess, _1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
                     case 0:
                         // if we iterated over the whole keySystemsType Array, quit on error
                         if (index >= keySystemsType.length) {
@@ -304,22 +315,23 @@ export default function getMediaKeySystemAccess(mediaElement, keySystemsConfigs,
                         if (eme.requestMediaKeySystemAccess == null) {
                             throw new Error("requestMediaKeySystemAccess is not implemented in your browser.");
                         }
-                        _a = keySystemsType[index], keyName = _a.keyName, keyType = _a.keyType, keySystemOptions = _a.keySystemOptions;
-                        keySystemConfigurations = buildKeySystemConfigurations(keyName, keyType, keySystemOptions);
+                        chosenType = keySystemsType[index];
+                        keyType = chosenType.keyType, keySystemOptions = chosenType.keySystemOptions;
+                        keySystemConfigurations = buildKeySystemConfigurations(chosenType);
                         log.debug("DRM: Request keysystem access ".concat(keyType, ",") +
                             "".concat(index + 1, " of ").concat(keySystemsType.length));
-                        _b.label = 1;
+                        _a.label = 1;
                     case 1:
-                        _b.trys.push([1, 3, , 4]);
+                        _a.trys.push([1, 3, , 4]);
                         return [4 /*yield*/, eme.requestMediaKeySystemAccess(keyType, keySystemConfigurations)];
                     case 2:
-                        keySystemAccess = _b.sent();
+                        keySystemAccess = _a.sent();
                         log.info("DRM: Found compatible keysystem", keyType, index + 1);
                         return [2 /*return*/, { type: "create-media-key-system-access",
                                 value: { options: keySystemOptions,
                                     mediaKeySystemAccess: keySystemAccess } }];
                     case 3:
-                        _1 = _b.sent();
+                        _1 = _a.sent();
                         log.debug("DRM: Rejected access to keysystem", keyType, index + 1);
                         if (cancelSignal.cancellationError !== null) {
                             throw cancelSignal.cancellationError;

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

@@ -64,15 +64,16 @@ import ServerCertificateStore from "./utils/server_certificate_store";
  * @returns {Object|null}
  */
 function createPersistentSessionsStorage(keySystemOptions) {
-    if (keySystemOptions.persistentLicense !== true) {
+    if (isNullOrUndefined(keySystemOptions.persistentLicenseConfig)) {
         return null;
     }
-    var licenseStorage = keySystemOptions.licenseStorage;
-    if (licenseStorage == null) {
-        throw new EncryptedMediaError("INVALID_KEY_SYSTEM", "No license storage found for persistent license.");
+    var persistentLicenseConfig = keySystemOptions.persistentLicenseConfig;
+    if (persistentLicenseConfig == null) {
+        throw new EncryptedMediaError("INVALID_KEY_SYSTEM", "No `persistentLicenseConfig` found for " +
+            "persistent license.");
     }
     log.debug("DRM: Set the given license storage");
-    return new PersistentSessionsStore(licenseStorage);
+    return new PersistentSessionsStore(persistentLicenseConfig);
 }
 /**
  * Create a MediaKeys instance and associated structures (or just return the

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

@@ -103,15 +103,18 @@ export default function SessionEventsListener(session, keySystemOptions, keySyst
         manualCanceller.cancel();
         callbacks.onError(new EncryptedMediaError("KEY_ERROR", evt.type));
     }, manualCanceller.signal);
-    onKeyStatusesChange(session, function (keyStatusesEvent) {
-        handleKeyStatusesChangeEvent(keyStatusesEvent).catch(function (error) {
+    onKeyStatusesChange(session, function () {
+        try {
+            checkAndHandleCurrentKeyStatuses();
+        }
+        catch (error) {
             if (cancelSignal.isCancelled() ||
                 (manualCanceller.isUsed() && error instanceof CancellationSignal)) {
                 return;
             }
             manualCanceller.cancel();
             callbacks.onError(error);
-        });
+        }
     }, manualCanceller.signal);
     onKeyMessage(session, function (evt) {
         var messageEvent = evt;
@@ -159,72 +162,6 @@ export default function SessionEventsListener(session, keySystemOptions, keySyst
     }, manualCanceller.signal);
     checkAndHandleCurrentKeyStatuses();
     return;
-    /**
-     * @param {Event} keyStatusesEvent
-     * @returns {Promise}
-     */
-    function handleKeyStatusesChangeEvent(keyStatusesEvent) {
-        return __awaiter(this, void 0, void 0, function () {
-            function runOnKeyStatusesChangeCallback() {
-                return __awaiter(this, void 0, void 0, function () {
-                    var ret, error_1, err;
-                    return __generator(this, function (_a) {
-                        switch (_a.label) {
-                            case 0:
-                                if (manualCanceller.isUsed()) {
-                                    return [2 /*return*/];
-                                }
-                                if (!(typeof keySystemOptions.onKeyStatusesChange === "function")) return [3 /*break*/, 7];
-                                ret = void 0;
-                                _a.label = 1;
-                            case 1:
-                                _a.trys.push([1, 3, , 4]);
-                                return [4 /*yield*/, keySystemOptions.onKeyStatusesChange(keyStatusesEvent, session)];
-                            case 2:
-                                ret = _a.sent();
-                                if (manualCanceller.isUsed()) {
-                                    return [2 /*return*/];
-                                }
-                                return [3 /*break*/, 4];
-                            case 3:
-                                error_1 = _a.sent();
-                                if (cancelSignal.isCancelled()) {
-                                    return [2 /*return*/];
-                                }
-                                err = new EncryptedMediaError("KEY_STATUS_CHANGE_ERROR", "Unknown `onKeyStatusesChange` error");
-                                if (!isNullOrUndefined(error_1) &&
-                                    isNonEmptyString(error_1.message)) {
-                                    err.message = error_1.message;
-                                }
-                                throw err;
-                            case 4:
-                                if (!isNullOrUndefined(ret)) return [3 /*break*/, 5];
-                                log.info("DRM: No license given, skipping session.update");
-                                return [3 /*break*/, 7];
-                            case 5: return [4 /*yield*/, updateSessionWithMessage(session, ret)];
-                            case 6:
-                                _a.sent();
-                                _a.label = 7;
-                            case 7: return [2 /*return*/];
-                        }
-                    });
-                });
-            }
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        log.info("DRM: keystatuseschange event received", session.sessionId);
-                        return [4 /*yield*/, Promise.all([
-                                runOnKeyStatusesChangeCallback(),
-                                Promise.resolve(checkAndHandleCurrentKeyStatuses()),
-                            ])];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    }
     /**
      * Check current MediaKeyStatus for each key in the given MediaKeySession and:
      *   - throw if at least one status is a non-recoverable error
@@ -232,6 +169,7 @@ export default function SessionEventsListener(session, keySystemOptions, keySyst
      *   - call onKeyUpdate callback when the MediaKeyStatus of any key is updated
      */
     function checkAndHandleCurrentKeyStatuses() {
+        log.info("DRM: keystatuseschange event received", session.sessionId);
         if (manualCanceller.isUsed() || session.keyStatuses.size === 0) {
             return;
         }
@@ -326,7 +264,7 @@ function formatGetLicenseError(error) {
  */
 function updateSessionWithMessage(session, message) {
     return __awaiter(this, void 0, void 0, function () {
-        var error_2, reason;
+        var error_1, reason;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
@@ -339,8 +277,8 @@ function updateSessionWithMessage(session, message) {
                     _a.sent();
                     return [3 /*break*/, 4];
                 case 3:
-                    error_2 = _a.sent();
-                    reason = error_2 instanceof Error ? error_2.toString() :
+                    error_1 = _a.sent();
+                    reason = error_1 instanceof Error ? error_1.toString() :
                         "`session.update` failed";
                     throw new EncryptedMediaError("KEY_UPDATE_ERROR", reason);
                 case 4:

package/dist/_esm5.processed/core/decrypt/utils/persistent_sessions_store.d.ts

@@ -14,11 +14,11 @@
  * limitations under the License.
  */
 import { ICustomMediaKeySession } from "../../../compat/eme";
-import { IPersistentSessionInfo, IPersistentSessionStorage } from "../../../public_types";
+import { IPersistentLicenseConfig, IPersistentSessionInfo } from "../../../public_types";
 import { IProcessedProtectionData } from "../types";
 /**
- * Set representing persisted licenses. Depends on a simple local-
- * storage implementation with a `save`/`load` synchronous interface
+ * Set representing persisted licenses. Depends on a simple
+ * implementation with a `save`/`load` synchronous interface
  * to persist information on persisted sessions.
  *
  * This set is used only for a cdm/keysystem with license persistency
@@ -32,7 +32,7 @@ export default class PersistentSessionsStore {
      * Create a new PersistentSessionsStore.
      * @param {Object} storage
      */
-    constructor(storage: IPersistentSessionStorage);
+    constructor(storage: IPersistentLicenseConfig);
     /**
      * Returns the number of stored values.
      * @returns {number}

package/dist/_esm5.processed/core/decrypt/utils/persistent_sessions_store.js

@@ -27,11 +27,11 @@ import SerializableBytes from "./serializable_bytes";
  * @param {Object} storage
  */
 function checkStorage(storage) {
-    assertInterface(storage, { save: "function", load: "function" }, "licenseStorage");
+    assertInterface(storage, { save: "function", load: "function" }, "persistentLicenseConfig");
 }
 /**
- * Set representing persisted licenses. Depends on a simple local-
- * storage implementation with a `save`/`load` synchronous interface
+ * Set representing persisted licenses. Depends on a simple
+ * implementation with a `save`/`load` synchronous interface
  * to persist information on persisted sessions.
  *
  * This set is used only for a cdm/keysystem with license persistency
@@ -299,7 +299,9 @@ var PersistentSessionsStore = /** @class */ (function () {
             this._storage.save(this._entries);
         }
         catch (e) {
-            log.warn("DRM-PSS: Could not save licenses in localStorage");
+            var err = e instanceof Error ? e :
+                undefined;
+            log.warn("DRM-PSS: Could not save MediaKeySession information", err);
         }
     };
     return PersistentSessionsStore;

package/dist/_esm5.processed/core/fetchers/manifest/manifest_fetcher.d.ts

@@ -163,9 +163,7 @@ export interface IManifestFetcherSettings {
      */
     lowLatencyMode: boolean;
     /** Maximum number of time a request on error will be retried. */
-    maxRetryRegular: number | undefined;
-    /** Maximum number of time a request be retried when the user is offline. */
-    maxRetryOffline: number | undefined;
+    maxRetry: number | undefined;
     /**
      * Timeout after which request are aborted and, depending on other options,
      * retried.

package/dist/_esm5.processed/core/fetchers/manifest/manifest_fetcher.js

@@ -68,7 +68,6 @@ import config from "../../../config";
 import { formatError } from "../../../errors";
 import log from "../../../log";
 import Manifest from "../../../manifest";
-import assert from "../../../utils/assert";
 import EventEmitter from "../../../utils/event_emitter";
 import isNullOrUndefined from "../../../utils/is_null_or_undefined";
 import noop from "../../../utils/noop";
@@ -184,20 +183,6 @@ var ManifestFetcher = /** @class */ (function (_super) {
     ManifestFetcher.prototype._fetchManifest = function (url) {
         var _a;
         return __awaiter(this, void 0, void 0, function () {
-            /**
-             * Call the resolver part of the pipeline, retrying if it fails according
-             * to the current settings.
-             * Returns the Promise of the last attempt.
-             * /!\ This pipeline should have a `resolveManifestUrl` function defined.
-             * @param {string | undefined}  resolverUrl
-             * @returns {Promise}
-             */
-            function callResolverWithRetries(resolverUrl) {
-                var resolveManifestUrl = pipelines.resolveManifestUrl;
-                assert(resolveManifestUrl !== undefined);
-                var callResolver = function () { return resolveManifestUrl(resolverUrl, cancelSignal); };
-                return scheduleRequestPromise(callResolver, backoffSettings, cancelSignal);
-            }
             /**
              * Call the loader part of the pipeline, retrying if it fails according
              * to the current settings.
@@ -216,7 +201,7 @@ var ManifestFetcher = /** @class */ (function (_super) {
                 var callLoader = function () { return loadManifest(manifestUrl, { timeout: requestTimeout }, cancelSignal); };
                 return scheduleRequestPromise(callLoader, backoffSettings, cancelSignal);
             }
-            var cancelSignal, settings, pipelines, requestUrl, backoffSettings, loadingPromise, response_1, err_1;
+            var cancelSignal, settings, pipelines, requestUrl, backoffSettings, response_1, err_1;
             var _this = this;
             return __generator(this, function (_b) {
                 switch (_b.label) {
@@ -228,13 +213,10 @@ var ManifestFetcher = /** @class */ (function (_super) {
                         backoffSettings = this._getBackoffSetting(function (err) {
                             _this.trigger("warning", errorSelector(err));
                         });
-                        loadingPromise = pipelines.resolveManifestUrl === undefined ?
-                            callLoaderWithRetries(requestUrl) :
-                            callResolverWithRetries(requestUrl).then(callLoaderWithRetries);
                         _b.label = 1;
                     case 1:
                         _b.trys.push([1, 3, , 4]);
-                        return [4 /*yield*/, loadingPromise];
+                        return [4 /*yield*/, callLoaderWithRetries(requestUrl)];
                     case 2:
                         response_1 = _b.sent();
                         return [2 /*return*/, {
@@ -378,15 +360,14 @@ var ManifestFetcher = /** @class */ (function (_super) {
      * @returns {Object}
      */
     ManifestFetcher.prototype._getBackoffSetting = function (onRetry) {
-        var _a = config.getCurrent(), DEFAULT_MAX_MANIFEST_REQUEST_RETRY = _a.DEFAULT_MAX_MANIFEST_REQUEST_RETRY, DEFAULT_MAX_REQUESTS_RETRY_ON_OFFLINE = _a.DEFAULT_MAX_REQUESTS_RETRY_ON_OFFLINE, INITIAL_BACKOFF_DELAY_BASE = _a.INITIAL_BACKOFF_DELAY_BASE, MAX_BACKOFF_DELAY_BASE = _a.MAX_BACKOFF_DELAY_BASE;
-        var _b = this._settings, lowLatencyMode = _b.lowLatencyMode, ogRegular = _b.maxRetryRegular, ogOffline = _b.maxRetryOffline;
+        var _a = config.getCurrent(), DEFAULT_MAX_MANIFEST_REQUEST_RETRY = _a.DEFAULT_MAX_MANIFEST_REQUEST_RETRY, INITIAL_BACKOFF_DELAY_BASE = _a.INITIAL_BACKOFF_DELAY_BASE, MAX_BACKOFF_DELAY_BASE = _a.MAX_BACKOFF_DELAY_BASE;
+        var _b = this._settings, lowLatencyMode = _b.lowLatencyMode, ogRegular = _b.maxRetry;
         var baseDelay = lowLatencyMode ? INITIAL_BACKOFF_DELAY_BASE.LOW_LATENCY :
             INITIAL_BACKOFF_DELAY_BASE.REGULAR;
         var maxDelay = lowLatencyMode ? MAX_BACKOFF_DELAY_BASE.LOW_LATENCY :
             MAX_BACKOFF_DELAY_BASE.REGULAR;
-        var maxRetryRegular = ogRegular !== null && ogRegular !== void 0 ? ogRegular : DEFAULT_MAX_MANIFEST_REQUEST_RETRY;
-        var maxRetryOffline = ogOffline !== null && ogOffline !== void 0 ? ogOffline : DEFAULT_MAX_REQUESTS_RETRY_ON_OFFLINE;
-        return { onRetry: onRetry, baseDelay: baseDelay, maxDelay: maxDelay, maxRetryRegular: maxRetryRegular, maxRetryOffline: maxRetryOffline };
+        var maxRetry = ogRegular !== null && ogRegular !== void 0 ? ogRegular : DEFAULT_MAX_MANIFEST_REQUEST_RETRY;
+        return { onRetry: onRetry, baseDelay: baseDelay, maxDelay: maxDelay, maxRetry: maxRetry };
     };
     /**
      * Performs Manifest refresh (recursively) when it judges it is time to do so.
@@ -539,7 +520,7 @@ var ManifestFetcher = /** @class */ (function (_super) {
         }
         else {
             fullRefresh = !enablePartialRefresh || manifestUpdateUrl === undefined;
-            refreshURL = fullRefresh ? manifest.getUrl() :
+            refreshURL = fullRefresh ? manifest.getUrls()[0] :
                 manifestUpdateUrl;
         }
         var externalClockOffset = manifest.clockOffset;

package/dist/_esm5.processed/core/fetchers/segment/segment_fetcher.d.ts

@@ -128,12 +128,7 @@ export interface ISegmentFetcherOptions {
      * Maximum number of retries to perform on "regular" errors (e.g. due to HTTP
      * status, integrity errors, timeouts...).
      */
-    maxRetryRegular: number;
-    /**
-     * Maximum number of retries to perform when it appears that the user is
-     * currently offline.
-     */
-    maxRetryOffline: number;
+    maxRetry: number;
     /**
      * Timeout after which request are aborted and, depending on other options,
      * retried.
@@ -146,9 +141,8 @@ export interface ISegmentFetcherOptions {
  * @param {Object}
  * @returns {Object}
  */
-export declare function getSegmentFetcherOptions(bufferType: string, { maxRetryRegular, maxRetryOffline, lowLatencyMode, requestTimeout }: {
-    maxRetryRegular?: number | undefined;
-    maxRetryOffline?: number | undefined;
+export declare function getSegmentFetcherOptions({ maxRetry, lowLatencyMode, requestTimeout }: {
+    maxRetry?: number | undefined;
     requestTimeout?: number | undefined;
     lowLatencyMode: boolean;
 }): ISegmentFetcherOptions;