rx-player 3.33.4-dev.2024083000 → 3.33.4

package/dist/_esm5.processed/core/decrypt/attach_media_keys.d.ts

@@ -13,10 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { ICustomMediaKeys, ICustomMediaKeySystemAccess, IEmeApiImplementation } from "../../compat/eme";
-import { IKeySystemOption } from "../../public_types";
-import { CancellationSignal } from "../../utils/task_canceller";
-import LoadedSessionsStore from "./utils/loaded_sessions_store";
+import type { ICustomMediaKeys, ICustomMediaKeySystemAccess, IEmeApiImplementation } from "../../compat/eme";
+import type { IKeySystemOption } from "../../public_types";
+import type { CancellationSignal } from "../../utils/task_canceller";
+import type LoadedSessionsStore from "./utils/loaded_sessions_store";
 /**
  * Dispose of the MediaKeys instance attached to the given media element, if
  * one.
@@ -33,7 +33,7 @@ export declare function disableMediaKeys(mediaElement: HTMLMediaElement): Promis
  * @param {Object} cancelSignal
  * @returns {Promise}
  */
-export default function attachMediaKeys(mediaElement: HTMLMediaElement, { emeImplementation, keySystemOptions, loadedSessionsStore, mediaKeySystemAccess, mediaKeys }: IMediaKeysState, cancelSignal: CancellationSignal): Promise<void>;
+export default function attachMediaKeys(mediaElement: HTMLMediaElement, { emeImplementation, keySystemOptions, askedConfiguration, loadedSessionsStore, mediaKeySystemAccess, mediaKeys, }: IMediaKeysState, cancelSignal: CancellationSignal): Promise<void>;
 /** MediaKeys and associated state attached to a media element. */
 export interface IMediaKeysState {
     /** Options set when the MediaKeys has been attached. */
@@ -44,6 +44,11 @@ export interface IMediaKeysState {
     mediaKeySystemAccess: MediaKeySystemAccess | ICustomMediaKeySystemAccess;
     /** The MediaKeys instance to attach to the media element. */
     mediaKeys: MediaKeys | ICustomMediaKeys;
+    /**
+     * The MediaKeySystemConfiguration that has been provided to the
+     * `requestMediaKeySystemAccess` API.
+     */
+    askedConfiguration: MediaKeySystemConfiguration;
     /**
      * The chosen EME implementation abstraction linked to `mediaKeys`.
      * Different EME implementation might for example be used while debugging or

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

@@ -60,7 +60,8 @@ import MediaKeysInfosStore from "./utils/media_keys_infos_store";
  */
 export function disableMediaKeys(mediaElement) {
     MediaKeysInfosStore.setState(mediaElement, null);
-    return eme.setMediaKeys(mediaElement, null)
+    return eme
+        .setMediaKeys(mediaElement, null)
         .then(function () {
         log.info("DRM: MediaKeys disabled with success");
     })
@@ -80,15 +81,14 @@ export function disableMediaKeys(mediaElement) {
 export default function attachMediaKeys(mediaElement_1, _a, cancelSignal_1) {
     return __awaiter(this, arguments, void 0, function (mediaElement, _b, cancelSignal) {
         var previousState, closeAllSessions;
-        var emeImplementation = _b.emeImplementation, keySystemOptions = _b.keySystemOptions, loadedSessionsStore = _b.loadedSessionsStore, mediaKeySystemAccess = _b.mediaKeySystemAccess, mediaKeys = _b.mediaKeys;
+        var emeImplementation = _b.emeImplementation, keySystemOptions = _b.keySystemOptions, askedConfiguration = _b.askedConfiguration, loadedSessionsStore = _b.loadedSessionsStore, mediaKeySystemAccess = _b.mediaKeySystemAccess, mediaKeys = _b.mediaKeys;
         return __generator(this, function (_c) {
             switch (_c.label) {
                 case 0:
                     previousState = MediaKeysInfosStore.getState(mediaElement);
-                    closeAllSessions = previousState !== null &&
-                        previousState.loadedSessionsStore !== loadedSessionsStore ?
-                        previousState.loadedSessionsStore.closeAllSessions() :
-                        Promise.resolve();
+                    closeAllSessions = previousState !== null && previousState.loadedSessionsStore !== loadedSessionsStore
+                        ? previousState.loadedSessionsStore.closeAllSessions()
+                        : Promise.resolve();
                     return [4 /*yield*/, closeAllSessions];
                 case 1:
                     _c.sent();
@@ -97,12 +97,20 @@ export default function attachMediaKeys(mediaElement_1, _a, cancelSignal_1) {
                     if (cancelSignal.isCancelled()) {
                         throw cancelSignal.cancellationError;
                     }
-                    MediaKeysInfosStore.setState(mediaElement, { emeImplementation: emeImplementation, keySystemOptions: keySystemOptions, mediaKeySystemAccess: mediaKeySystemAccess, mediaKeys: mediaKeys, loadedSessionsStore: loadedSessionsStore });
+                    MediaKeysInfosStore.setState(mediaElement, {
+                        emeImplementation: emeImplementation,
+                        keySystemOptions: keySystemOptions,
+                        mediaKeySystemAccess: mediaKeySystemAccess,
+                        mediaKeys: mediaKeys,
+                        loadedSessionsStore: loadedSessionsStore,
+                        askedConfiguration: askedConfiguration,
+                    });
                     if (mediaElement.mediaKeys === mediaKeys) {
                         return [2 /*return*/];
                     }
                     log.info("DRM: Attaching MediaKeys to the media element");
-                    emeImplementation.setMediaKeys(mediaElement, mediaKeys)
+                    emeImplementation
+                        .setMediaKeys(mediaElement, mediaKeys)
                         .then(function () {
                         log.info("DRM: MediaKeys attached with success");
                     })

package/dist/_esm5.processed/core/decrypt/content_decryptor.d.ts

@@ -13,9 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { IKeySystemOption } from "../../public_types";
+import type { IKeySystemOption } from "../../public_types";
 import EventEmitter from "../../utils/event_emitter";
-import { IProtectionData, ContentDecryptorState, IContentDecryptorEvent } from "./types";
+import type { IProtectionData, IContentDecryptorEvent } from "./types";
+import { ContentDecryptorState } from "./types";
 /**
  * Module communicating with the Content Decryption Module (or CDM) to be able
  * to decrypt contents.
@@ -145,6 +146,14 @@ export default class ContentDecryptor extends EventEmitter<IContentDecryptorEven
      */
     private _processInitializationData;
     private _tryToUseAlreadyCreatedSession;
+    /**
+     * Remove the session corresponding to the initData provided, and close it.
+     * It does nothing if no session was found for this initData.
+     * @param {Object} initData : The initialization data corresponding to the session
+     * that need to be removed
+     * @param {Object} mediaKeysData : The media keys data
+     */
+    private removeSessionForInitData;
     /**
      * Callback that should be called if an error that made the current
      * `ContentDecryptor` instance unusable arised.

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

@@ -84,9 +84,9 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     }
     return to.concat(ar || Array.prototype.slice.call(from));
 };
-import eme, { getInitData, } from "../../compat/eme";
+import eme, { getInitData } from "../../compat/eme";
 import config from "../../config";
-import { EncryptedMediaError, OtherError, } from "../../errors";
+import { EncryptedMediaError, OtherError } from "../../errors";
 import log from "../../log";
 import areArraysOfNumbersEqual from "../../utils/are_arrays_of_numbers_equal";
 import arrayFind from "../../utils/array_find";
@@ -100,7 +100,7 @@ import createOrLoadSession from "./create_or_load_session";
 import initMediaKeys from "./init_media_keys";
 import SessionEventsListener, { BlacklistedSessionError, } from "./session_events_listener";
 import setServerCertificate from "./set_server_certificate";
-import { ContentDecryptorState, } from "./types";
+import { ContentDecryptorState } from "./types";
 import { DecommissionedSessionError } from "./utils/check_key_statuses";
 import cleanOldStoredPersistentInfo from "./utils/clean_old_stored_persistent_info";
 import getDrmSystemId from "./utils/get_drm_system_id";
@@ -141,10 +141,12 @@ var ContentDecryptor = /** @class */ (function (_super) {
         _this._currentSessions = [];
         _this._canceller = canceller;
         _this._initDataQueue = [];
-        _this._stateData = { state: ContentDecryptorState.Initializing,
+        _this._stateData = {
+            state: ContentDecryptorState.Initializing,
             isMediaKeysAttached: 0 /* MediaKeyAttachmentStatus.NotAttached */,
             isInitDataQueueLocked: true,
-            data: null };
+            data: null,
+        };
         _this.error = null;
         eme.onEncrypted(mediaElement, function (evt) {
             log.debug("DRM: Encrypted event received from media element.");
@@ -172,10 +174,12 @@ var ContentDecryptor = /** @class */ (function (_super) {
             }
             _this.systemId = systemId;
             if (_this._stateData.state === ContentDecryptorState.Initializing) {
-                _this._stateData = { state: ContentDecryptorState.WaitingForAttachment,
+                _this._stateData = {
+                    state: ContentDecryptorState.WaitingForAttachment,
                     isInitDataQueueLocked: true,
                     isMediaKeysAttached: 0 /* MediaKeyAttachmentStatus.NotAttached */,
-                    data: { mediaKeysInfo: mediaKeysInfo, mediaElement: mediaElement } };
+                    data: { mediaKeysInfo: mediaKeysInfo, mediaElement: mediaElement },
+                };
                 _this.trigger("stateChange", _this._stateData.state);
             }
         })
@@ -213,21 +217,22 @@ var ContentDecryptor = /** @class */ (function (_super) {
     ContentDecryptor.prototype.attach = function () {
         var _this = this;
         if (this._stateData.state !== ContentDecryptorState.WaitingForAttachment) {
-            throw new Error("`attach` should only be called when " +
-                "in the WaitingForAttachment state");
+            throw new Error("`attach` should only be called when " + "in the WaitingForAttachment state");
         }
         else if (this._stateData.isMediaKeysAttached !== 0 /* MediaKeyAttachmentStatus.NotAttached */) {
             log.warn("DRM: ContentDecryptor's `attach` method called more than once.");
             return;
         }
         var _a = this._stateData.data, mediaElement = _a.mediaElement, mediaKeysInfo = _a.mediaKeysInfo;
-        var options = mediaKeysInfo.options, mediaKeys = mediaKeysInfo.mediaKeys, mediaKeySystemAccess = mediaKeysInfo.mediaKeySystemAccess, stores = mediaKeysInfo.stores;
+        var options = mediaKeysInfo.options, mediaKeys = mediaKeysInfo.mediaKeys, mediaKeySystemAccess = mediaKeysInfo.mediaKeySystemAccess, stores = mediaKeysInfo.stores, askedConfiguration = mediaKeysInfo.askedConfiguration;
         var shouldDisableLock = options.disableMediaKeysAttachmentLock === true;
         if (shouldDisableLock) {
-            this._stateData = { state: ContentDecryptorState.ReadyForContent,
+            this._stateData = {
+                state: ContentDecryptorState.ReadyForContent,
                 isInitDataQueueLocked: true,
                 isMediaKeysAttached: 1 /* MediaKeyAttachmentStatus.Pending */,
-                data: { mediaKeysInfo: mediaKeysInfo, mediaElement: mediaElement } };
+                data: { mediaKeysInfo: mediaKeysInfo, mediaElement: mediaElement },
+            };
             this.trigger("stateChange", this._stateData.state);
             // previous trigger might have lead to disposal
             if (this._isStopped()) {
@@ -235,8 +240,14 @@ var ContentDecryptor = /** @class */ (function (_super) {
             }
         }
         this._stateData.isMediaKeysAttached = 1 /* MediaKeyAttachmentStatus.Pending */;
-        var stateToAttach = { emeImplementation: eme,
-            loadedSessionsStore: stores.loadedSessionsStore, mediaKeySystemAccess: mediaKeySystemAccess, mediaKeys: mediaKeys, keySystemOptions: options };
+        var stateToAttach = {
+            emeImplementation: eme,
+            loadedSessionsStore: stores.loadedSessionsStore,
+            mediaKeySystemAccess: mediaKeySystemAccess,
+            mediaKeys: mediaKeys,
+            askedConfiguration: askedConfiguration,
+            keySystemOptions: options,
+        };
         log.debug("DRM: Attaching current MediaKeys");
         attachMediaKeys(mediaElement, stateToAttach, this._canceller.signal)
             .then(function () { return __awaiter(_this, void 0, void 0, function () {
@@ -255,14 +266,17 @@ var ContentDecryptor = /** @class */ (function (_super) {
                         }
                         _a.label = 2;
                     case 2:
-                        if (this._isStopped()) { // We might be stopped since then
+                        if (this._isStopped()) {
+                            // We might be stopped since then
                             return [2 /*return*/];
                         }
                         prevState = this._stateData.state;
-                        this._stateData = { state: ContentDecryptorState.ReadyForContent,
+                        this._stateData = {
+                            state: ContentDecryptorState.ReadyForContent,
                             isMediaKeysAttached: 2 /* MediaKeyAttachmentStatus.Attached */,
                             isInitDataQueueLocked: false,
-                            data: { mediaKeysData: mediaKeysInfo } };
+                            data: { mediaKeysData: mediaKeysInfo },
+                        };
                         if (prevState !== ContentDecryptorState.ReadyForContent) {
                             this.trigger("stateChange", ContentDecryptorState.ReadyForContent);
                         }
@@ -286,10 +300,12 @@ var ContentDecryptor = /** @class */ (function (_super) {
      */
     ContentDecryptor.prototype.dispose = function () {
         this.removeEventListener();
-        this._stateData = { state: ContentDecryptorState.Disposed,
+        this._stateData = {
+            state: ContentDecryptorState.Disposed,
             isMediaKeysAttached: undefined,
             isInitDataQueueLocked: undefined,
-            data: null };
+            data: null,
+        };
         this._canceller.cancel();
         this.trigger("stateChange", this._stateData.state);
     };
@@ -313,8 +329,9 @@ var ContentDecryptor = /** @class */ (function (_super) {
         }
         var mediaKeysData = this._stateData.data.mediaKeysData;
         var processedInitializationData = __assign(__assign({}, initializationData), { values: new InitDataValuesContainer(initializationData.values) });
-        this._processInitializationData(processedInitializationData, mediaKeysData)
-            .catch(function (err) { _this._onFatalError(err); });
+        this._processInitializationData(processedInitializationData, mediaKeysData).catch(function (err) {
+            _this._onFatalError(err);
+        });
     };
     /**
      * Async logic run each time new initialization data has to be processed.
@@ -334,14 +351,12 @@ var ContentDecryptor = /** @class */ (function (_super) {
                     case 0:
                         mediaKeySystemAccess = mediaKeysData.mediaKeySystemAccess, stores = mediaKeysData.stores, options = mediaKeysData.options;
                         if (this._tryToUseAlreadyCreatedSession(initializationData, mediaKeysData) ||
-                            this._isStopped()) // _isStopped is voluntarly checked after here
-                         {
+                            this._isStopped()) {
+                            // _isStopped is voluntarly checked after here
                             return [2 /*return*/];
                         }
                         if (options.singleLicensePer === "content") {
-                            firstCreatedSession = arrayFind(this._currentSessions, function (x) {
-                                return x.source === "created-session" /* MediaKeySessionLoadingType.Created */;
-                            });
+                            firstCreatedSession = arrayFind(this._currentSessions, function (x) { return x.source === "created-session" /* MediaKeySessionLoadingType.Created */; });
                             if (firstCreatedSession !== undefined) {
                                 keyIds = initializationData.keyIds;
                                 if (keyIds === undefined) {
@@ -356,8 +371,7 @@ var ContentDecryptor = /** @class */ (function (_super) {
                                 firstCreatedSession.record.associateKeyIds(keyIds);
                                 if (initializationData.content !== undefined) {
                                     if (log.hasLevel("DEBUG")) {
-                                        hexKids = keyIds
-                                            .reduce(function (acc, kid) { return "".concat(acc, ", ").concat(bytesToHex(kid)); }, "");
+                                        hexKids = keyIds.reduce(function (acc, kid) { return "".concat(acc, ", ").concat(bytesToHex(kid)); }, "");
                                         log.debug("DRM: Blacklisting new key ids", hexKids);
                                     }
                                     updateDecipherability(initializationData.content.manifest, [], keyIds, []);
@@ -368,8 +382,7 @@ var ContentDecryptor = /** @class */ (function (_super) {
                         else if (options.singleLicensePer === "periods" &&
                             initializationData.content !== undefined) {
                             period = initializationData.content.period;
-                            createdSessions = this._currentSessions
-                                .filter(function (x) { return x.source === "created-session" /* MediaKeySessionLoadingType.Created */; });
+                            createdSessions = this._currentSessions.filter(function (x) { return x.source === "created-session" /* MediaKeySessionLoadingType.Created */; });
                             periodKeys = new Set();
                             addKeyIdsFromPeriod(periodKeys, period);
                             for (_i = 0, createdSessions_1 = createdSessions; _i < createdSessions_1.length; _i++) {
@@ -380,10 +393,12 @@ var ContentDecryptor = /** @class */ (function (_super) {
                                     if (createdSess.record.isAssociatedWithKeyId(kid)) {
                                         createdSess.record.associateKeyIds(periodKeys.values());
                                         _loop_1 = function (innerKid) {
-                                            if (!createdSess.keyStatuses.whitelisted
-                                                .some(function (k) { return areArraysOfNumbersEqual(k, innerKid); }) &&
-                                                !createdSess.keyStatuses.blacklisted
-                                                    .some(function (k) { return areArraysOfNumbersEqual(k, innerKid); })) {
+                                            if (!createdSess.keyStatuses.whitelisted.some(function (k) {
+                                                return areArraysOfNumbersEqual(k, innerKid);
+                                            }) &&
+                                                !createdSess.keyStatuses.blacklisted.some(function (k) {
+                                                    return areArraysOfNumbersEqual(k, innerKid);
+                                                })) {
                                                 createdSess.keyStatuses.blacklisted.push(innerKid);
                                             }
                                         };
@@ -409,16 +424,16 @@ var ContentDecryptor = /** @class */ (function (_super) {
                             wantedSessionType = "temporary";
                         }
                         else if (!canCreatePersistentSession(mediaKeySystemAccess)) {
-                            log.warn("DRM: Cannot create \"persistent-license\" session: not supported");
+                            log.warn('DRM: Cannot create "persistent-license" session: not supported');
                             wantedSessionType = "temporary";
                         }
                         else {
                             wantedSessionType = "persistent-license";
                         }
                         _c = config.getCurrent(), EME_DEFAULT_MAX_SIMULTANEOUS_MEDIA_KEY_SESSIONS = _c.EME_DEFAULT_MAX_SIMULTANEOUS_MEDIA_KEY_SESSIONS, EME_MAX_STORED_PERSISTENT_SESSION_INFORMATION = _c.EME_MAX_STORED_PERSISTENT_SESSION_INFORMATION;
-                        maxSessionCacheSize = typeof options.maxSessionCacheSize === "number" ?
-                            options.maxSessionCacheSize :
-                            EME_DEFAULT_MAX_SIMULTANEOUS_MEDIA_KEY_SESSIONS;
+                        maxSessionCacheSize = typeof options.maxSessionCacheSize === "number"
+                            ? options.maxSessionCacheSize
+                            : EME_DEFAULT_MAX_SIMULTANEOUS_MEDIA_KEY_SESSIONS;
                         return [4 /*yield*/, createOrLoadSession(initializationData, stores, wantedSessionType, maxSessionCacheSize, this._canceller.signal)];
                     case 1:
                         sessionRes = _e.sent();
@@ -439,8 +454,10 @@ var ContentDecryptor = /** @class */ (function (_super) {
                                 var linkedKeys = getKeyIdsLinkedToSession(initializationData, sessionInfo.record, options.singleLicensePer, sessionInfo.source === "created-session" /* MediaKeySessionLoadingType.Created */, value.whitelistedKeyIds, value.blacklistedKeyIds);
                                 sessionInfo.record.associateKeyIds(linkedKeys.whitelisted);
                                 sessionInfo.record.associateKeyIds(linkedKeys.blacklisted);
-                                sessionInfo.keyStatuses = { whitelisted: linkedKeys.whitelisted,
-                                    blacklisted: linkedKeys.blacklisted };
+                                sessionInfo.keyStatuses = {
+                                    whitelisted: linkedKeys.whitelisted,
+                                    blacklisted: linkedKeys.blacklisted,
+                                };
                                 if (sessionInfo.record.getAssociatedKeyIds().length !== 0 &&
                                     sessionType === "persistent-license" &&
                                     stores.persistentSessionsStore !== null &&
@@ -471,10 +488,10 @@ var ContentDecryptor = /** @class */ (function (_super) {
                                         updateDecipherability(initializationData.content.manifest, [], [], sessionInfo.record.getAssociatedKeyIds());
                                     }
                                     (_a = stores.persistentSessionsStore) === null || _a === void 0 ? void 0 : _a.delete(mediaKeySession.sessionId);
-                                    stores.loadedSessionsStore.closeSession(mediaKeySession)
+                                    stores.loadedSessionsStore
+                                        .closeSession(mediaKeySession)
                                         .catch(function (e) {
-                                        var closeError = e instanceof Error ? e :
-                                            "unknown error";
+                                        var closeError = e instanceof Error ? e : "unknown error";
                                         log.warn("DRM: failed to close expired session", closeError);
                                     })
                                         .then(function () { return _this._unlockInitDataQueue(); })
@@ -491,8 +508,7 @@ var ContentDecryptor = /** @class */ (function (_super) {
                                 sessionInfo.blacklistedSessionError = err;
                                 if (initializationData.content !== undefined) {
                                     var manifest = initializationData.content.manifest;
-                                    log.info("DRM: blacklisting Representations based on " +
-                                        "protection data.");
+                                    log.info("DRM: blacklisting Representations based on " + "protection data.");
                                     blackListProtectionData(manifest, initializationData);
                                 }
                                 _this._unlockInitDataQueue();
@@ -522,8 +538,7 @@ var ContentDecryptor = /** @class */ (function (_super) {
                             }
                             return [2 /*return*/, Promise.resolve()];
                         }
-                        throw new EncryptedMediaError("KEY_GENERATE_REQUEST_ERROR", error_1 instanceof Error ? error_1.toString() :
-                            "Unknown error");
+                        throw new EncryptedMediaError("KEY_GENERATE_REQUEST_ERROR", error_1 instanceof Error ? error_1.toString() : "Unknown error");
                     case 5: return [2 /*return*/, Promise.resolve()];
                 }
             });
@@ -535,10 +550,27 @@ var ContentDecryptor = /** @class */ (function (_super) {
          * If set, a currently-used key session is already compatible to this
          * initialization data.
          */
-        var compatibleSessionInfo = arrayFind(this._currentSessions, function (x) { return x.record.isCompatibleWith(initializationData); });
+        var compatibleSessionInfo = arrayFind(this._currentSessions, function (x) {
+            return x.record.isCompatibleWith(initializationData);
+        });
         if (compatibleSessionInfo === undefined) {
             return false;
         }
+        /**
+         * On Safari using Directfile, the old EME implementation triggers
+         * the "webkitneedkey" event instead of "encrypted". There's an issue in
+         * Safari where "webkitneedkey" fires too early before all tracks are added
+         * from an HLS playlist.
+         * Safari incorrectly assumes some keys are missing for these tracks,
+         * leading to repeated "webkitneedkey" events. Because RxPlayer recognizes
+         * it already has a session for these keys and ignores the events,
+         * the content remains frozen. To resolve this, the session is re-created.
+         */
+        var forceSessionRecreation = initializationData.forceSessionRecreation;
+        if (forceSessionRecreation === true) {
+            this.removeSessionForInitData(initializationData, mediaKeysData);
+            return false;
+        }
         // Check if the compatible session is blacklisted
         var blacklistedSessionError = compatibleSessionInfo.blacklistedSessionError;
         if (!isNullOrUndefined(blacklistedSessionError)) {
@@ -619,6 +651,42 @@ var ContentDecryptor = /** @class */ (function (_super) {
         }
         return false;
     };
+    /**
+     * Remove the session corresponding to the initData provided, and close it.
+     * It does nothing if no session was found for this initData.
+     * @param {Object} initData : The initialization data corresponding to the session
+     * that need to be removed
+     * @param {Object} mediaKeysData : The media keys data
+     */
+    ContentDecryptor.prototype.removeSessionForInitData = function (initData, mediaKeysData) {
+        var stores = mediaKeysData.stores;
+        /** Remove the session and close it from the loadedSessionStore */
+        var entry = stores.loadedSessionsStore.reuse(initData);
+        if (entry !== null) {
+            stores.loadedSessionsStore
+                .closeSession(entry.mediaKeySession)
+                .catch(function () {
+                return log.error("DRM: Cannot close the session from the loaded session store");
+            });
+        }
+        /**
+         * If set, a currently-used key session is already compatible to this
+         * initialization data.
+         */
+        var compatibleSessionInfo = arrayFind(this._currentSessions, function (x) {
+            return x.record.isCompatibleWith(initData);
+        });
+        if (compatibleSessionInfo === undefined) {
+            return;
+        }
+        /** Remove the session from the currentSessions */
+        var indexOf = this._currentSessions.indexOf(compatibleSessionInfo);
+        if (indexOf !== -1) {
+            log.debug("DRM: A session from a processed init is removed " +
+                "due to forceSessionRecreation policy.");
+            this._currentSessions.splice(indexOf, 1);
+        }
+    };
     /**
      * Callback that should be called if an error that made the current
      * `ContentDecryptor` instance unusable arised.
@@ -633,15 +701,15 @@ var ContentDecryptor = /** @class */ (function (_super) {
         if (this._canceller.isUsed()) {
             return;
         }
-        var formattedErr = err instanceof Error ?
-            err :
-            new OtherError("NONE", "Unknown decryption error");
+        var formattedErr = err instanceof Error ? err : new OtherError("NONE", "Unknown decryption error");
         this.error = formattedErr;
         this._initDataQueue.length = 0;
-        this._stateData = { state: ContentDecryptorState.Error,
+        this._stateData = {
+            state: ContentDecryptorState.Error,
             isMediaKeysAttached: undefined,
             isInitDataQueueLocked: undefined,
-            data: null };
+            data: null,
+        };
         this._canceller.cancel();
         this.trigger("error", formattedErr);
         // The previous trigger might have lead to a disposal of the `ContentDecryptor`.
@@ -655,8 +723,8 @@ var ContentDecryptor = /** @class */ (function (_super) {
      * @returns {boolean}
      */
     ContentDecryptor.prototype._isStopped = function () {
-        return this._stateData.state === ContentDecryptorState.Disposed ||
-            this._stateData.state === ContentDecryptorState.Error;
+        return (this._stateData.state === ContentDecryptorState.Disposed ||
+            this._stateData.state === ContentDecryptorState.Error);
     };
     /**
      * Start processing the next initialization data of the `_initDataQueue` if it
@@ -707,8 +775,7 @@ export default ContentDecryptor;
  */
 function canCreatePersistentSession(mediaKeySystemAccess) {
     var sessionTypes = mediaKeySystemAccess.getConfiguration().sessionTypes;
-    return sessionTypes !== undefined &&
-        arrayIncludes(sessionTypes, "persistent-license");
+    return sessionTypes !== undefined && arrayIncludes(sessionTypes, "persistent-license");
 }
 /**
  * Change the decipherability of Representations which have their key id in one
@@ -774,14 +841,14 @@ function blackListProtectionData(manifest, initData) {
         }
         var segmentProtections = (_b = (_a = representation.contentProtections) === null || _a === void 0 ? void 0 : _a.initData) !== null && _b !== void 0 ? _b : [];
         var _loop_2 = function (protection) {
-            if (initData.type === undefined ||
-                protection.type === initData.type) {
-                var containedInitData = initData.values.getFormattedValues()
+            if (initData.type === undefined || protection.type === initData.type) {
+                var containedInitData = initData.values
+                    .getFormattedValues()
                     .every(function (undecipherableVal) {
                     return protection.values.some(function (currVal) {
-                        return (undecipherableVal.systemId === undefined ||
+                        return ((undecipherableVal.systemId === undefined ||
                             currVal.systemId === undecipherableVal.systemId) &&
-                            areArraysOfNumbersEqual(currVal.data, undecipherableVal.data);
+                            areArraysOfNumbersEqual(currVal.data, undecipherableVal.data));
                     });
                 });
                 if (containedInitData) {
@@ -905,7 +972,9 @@ function getKeyIdsLinkedToSession(initializationData, keySessionRecord, singleLi
                     else {
                         var periodKeysArr = Array.from(periodKeys);
                         var _loop_4 = function (kid) {
-                            var isFound = associatedKeyIds.some(function (k) { return areArraysOfNumbersEqual(k, kid); });
+                            var isFound = associatedKeyIds.some(function (k) {
+                                return areArraysOfNumbersEqual(k, kid);
+                            });
                             if (isFound) {
                                 mergeKeyIdSetIntoArray(periodKeys, associatedKeyIds);
                                 return "break";
@@ -922,9 +991,11 @@ function getKeyIdsLinkedToSession(initializationData, keySessionRecord, singleLi
             }
         }
     }
-    return { whitelisted: usableKeyIds,
+    return {
+        whitelisted: usableKeyIds,
         /** associatedKeyIds starts with the whitelisted one. */
-        blacklisted: associatedKeyIds.slice(usableKeyIds.length) };
+        blacklisted: associatedKeyIds.slice(usableKeyIds.length),
+    };
 }
 /**
  * Push all kei ids in the given `set` and add it to the `arr` Array only if it

package/dist/_esm5.processed/core/decrypt/create_or_load_session.d.ts

@@ -13,10 +13,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { ICustomMediaKeySession } from "../../compat/eme";
-import { CancellationSignal } from "../../utils/task_canceller";
-import { IProcessedProtectionData, IMediaKeySessionStores, MediaKeySessionLoadingType } from "./types";
-import KeySessionRecord from "./utils/key_session_record";
+import type { ICustomMediaKeySession } from "../../compat/eme";
+import type { CancellationSignal } from "../../utils/task_canceller";
+import type { IProcessedProtectionData, IMediaKeySessionStores } from "./types";
+import { MediaKeySessionLoadingType } from "./types";
+import type KeySessionRecord from "./utils/key_session_record";
 /**
  * Handle MediaEncryptedEvents sent by a HTMLMediaElement:
  * Either create a MediaKeySession, recuperate a previous MediaKeySession or

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

@@ -83,10 +83,14 @@ export default function createOrLoadSession(initializationData, stores, wantedSe
                         previousLoadedSession = entry.mediaKeySession;
                         if (isSessionUsable(previousLoadedSession)) {
                             log.info("DRM: Reuse loaded session", previousLoadedSession.sessionId);
-                            return [2 /*return*/, { type: "loaded-open-session" /* MediaKeySessionLoadingType.LoadedOpenSession */,
-                                    value: { mediaKeySession: previousLoadedSession,
+                            return [2 /*return*/, {
+                                    type: "loaded-open-session" /* MediaKeySessionLoadingType.LoadedOpenSession */,
+                                    value: {
+                                        mediaKeySession: previousLoadedSession,
                                         sessionType: entry.sessionType,
-                                        keySessionRecord: entry.keySessionRecord } }];
+                                        keySessionRecord: entry.keySessionRecord,
+                                    },
+                                }];
                         }
                         else if (persistentSessionsStore !== null) {
                             // If the session is not usable anymore, we can also remove it from the
@@ -105,7 +109,10 @@ export default function createOrLoadSession(initializationData, stores, wantedSe
                         throw cancelSignal.cancellationError; // stop here if cancelled since
                     }
                     _a.label = 2;
-                case 2: return [4 /*yield*/, cleanOldLoadedSessions(loadedSessionsStore, maxSessionCacheSize)];
+                case 2: return [4 /*yield*/, cleanOldLoadedSessions(loadedSessionsStore, 
+                    // Account for the next session we will be creating
+                    // Note that `maxSessionCacheSize < 0 has special semantic (no limit)`
+                    maxSessionCacheSize <= 0 ? maxSessionCacheSize : maxSessionCacheSize - 1)];
                 case 3:
                     _a.sent();
                     if (cancelSignal.cancellationError !== null) {
@@ -114,10 +121,14 @@ export default function createOrLoadSession(initializationData, stores, wantedSe
                     return [4 /*yield*/, createSession(stores, initializationData, wantedSessionType, cancelSignal)];
                 case 4:
                     evt = _a.sent();
-                    return [2 /*return*/, { type: evt.type,
-                            value: { mediaKeySession: evt.value.mediaKeySession,
+                    return [2 /*return*/, {
+                            type: evt.type,
+                            value: {
+                                mediaKeySession: evt.value.mediaKeySession,
                                 sessionType: evt.value.sessionType,
-                                keySessionRecord: evt.value.keySessionRecord } }];
+                                keySessionRecord: evt.value.keySessionRecord,
+                            },
+                        }];
             }
         });
     });

package/dist/_esm5.processed/core/decrypt/create_session.d.ts

@@ -13,10 +13,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { ICustomMediaKeySession } from "../../compat/eme";
-import { CancellationSignal } from "../../utils/task_canceller";
-import { IProcessedProtectionData, IMediaKeySessionStores, MediaKeySessionLoadingType } from "./types";
-import KeySessionRecord from "./utils/key_session_record";
+import type { ICustomMediaKeySession } from "../../compat/eme";
+import type { CancellationSignal } from "../../utils/task_canceller";
+import type { IProcessedProtectionData, IMediaKeySessionStores } from "./types";
+import { MediaKeySessionLoadingType } from "./types";
+import type KeySessionRecord from "./utils/key_session_record";
 /**
  * Create a new Session or load a persistent one on the given MediaKeys,
  * according to wanted settings and what is currently stored.